Suite

Phrase MapBasic pour mettre à jour la colonne contenue dans une table d'objets

Phrase MapBasic pour mettre à jour la colonne contenue dans une table d'objets


Je cherchais une phrase MapBasic pour mettre à jour une table MapInfo. J'ai deux tables et je veux mettre à jour l'une d'entre elles (POINTS) avec un attribut d'un autre (REGIONS). Je voudrais mettre à jour les points avec le nom des régions contenues. Je veux dire, j'ai deux tables dans MapInfo, une table de polygones et une table de points. Je veux remplir la colonne "municipalité" avec les noms des polygones qui contiennent les points.

J'essayais avec différentes possibilités, en utilisant la commande "update" telle que

Mettre à jour {Table de texte} Définir {Column}=ObjectInfo(Obj,3) Sélectionner * À partir de {Table de texte} Où Str$(Obj)=”TEXT”

Table POINTS (avec colonne REGION_NAME),

Tableau REGIONS (avec colonne NOM)

Ajouter la colonne "POINTS" (REGION_NAME) De REGIONS Définir sur NAME Où contient

Vous devez remplacer les noms de vos tables et colonnes réelles.


Comment soumettre des données d'une table répétable sous forme d'infopath à une liste sharepoint ?

J'ai un formulaire infopath créé à partir d'un type de contenu de liste sharepoint. Dans ce formulaire, j'ai besoin d'ajouter une table reproductible pour envoyer des données à une autre liste sharepoint. Ainsi, lorsque les gens soumettent ce formulaire, la liste originale sur laquelle le formulaire est basé sera mise à jour ainsi que la deuxième liste. Comment puis-je soumettre des données à cette deuxième liste sharepoint ?

J'ai déjà créé un service Web WCF qui peut ajouter des éléments à une liste mais cela ne fonctionne pas avec infopath.

Quelqu'un peut-il me montrer des instructions sur la façon de créer ou d'utiliser un service Web qui me permet de soumettre des champs à une liste sharepoint, puis de l'utiliser dans infopath 2010 ?


1 réponse 1

Existe-t-il un meilleur moyen?
Entity Framework fournit-il déjà un mécanisme pour y parvenir ?

En fait, c'est une question. Si EF fournissait un mécanisme, ce serait sans aucun doute mieux, car vous sauriez avec certitude qu'il produit quelque chose dont EF est satisfait. Malheureusement, non, EF n'a pas un tel mécanisme.

Dans la mesure où EF vérifie la cohérence de la base de données avec un modèle existant, il ne compare qu'un hachage de modèle précédemment stocké dans la base de données avec le hachage de modèle actuel. Il ne compare jamais les objets de base de données réels. Cela prendrait beaucoup trop de temps pour vérifier si une migration doit être appliquée. Et puis, toutes ces méthodes sont internes.

Il existe cependant un moyen plus court et plus fiable d'obtenir des noms d'entités et de propriétés à partir d'un contexte. Plus fiable, car vous n'obtiendrez que les entités et propriétés mappées sans avoir à franchir des étapes pour exclure celles qui ne sont pas mappées. Je vais vous en donner le cœur, afin que vous puissiez l'intégrer de manière appropriée.

Serait-ce mieux dans la couche de données ou dans un autre assemblage ?

Je ferais de la partie qui fournit les noms de table et de colonne une partie de la couche de données, car vous y avez toutes les références requises. Je n'inclurais pas la partie qui interroge la base de données, car c'est fait avec Dapper, et.

L'ajout de Dapper (juste à cette fin) est-il excessif, ajoute-t-il une complexité inutile au projet ?

Non, Dapper est génial. Mais comme il s'agit d'une dépendance tierce, je l'utiliserais dans un assembly séparé qui a une référence à votre DAL (pour obtenir les noms d'objet de base de données), donc votre DAL n'a pas cette dépendance.


1 réponse 1

Dans certaines circonstances, la suppression d'une colonne peut être une opération de métadonnées uniquement. Les définitions de colonne pour une table donnée ne sont pas incluses dans chaque page où les lignes sont stockées, les définitions de colonne ne sont stockées que dans les métadonnées de la base de données, y compris sys.sysrowsets, sys.sysrscols, etc.

Lors de la suppression d'une colonne qui n'est référencée par aucun autre objet, le moteur de stockage marque simplement la définition de colonne comme n'étant plus présente en supprimant les détails pertinents de diverses tables système. L'action de suppression des métadonnées invalide le cache de procédure, ce qui nécessite une recompilation chaque fois qu'une requête fait ensuite référence à cette table. Étant donné que la recompilation ne renvoie que les colonnes qui actuellement existent dans la table, les détails de la colonne supprimée ne sont même jamais demandés car le moteur de stockage ignore les octets stockés dans chaque page pour cette colonne, comme si la colonne n'existait plus.

Lorsqu'une opération DML suivante se produit sur la table, les pages affectées sont réécrites sans les données de la colonne supprimée. Si vous reconstruisez un index clusterisé ou un tas, tous les octets de la colonne supprimée ne sont naturellement pas réécrits sur la page sur le disque. Cela répartit efficacement la charge de la chute de la colonne dans le temps, la rendant moins visible.

Dans certaines circonstances, vous ne pouvez pas supprimer une colonne, par exemple lorsque la colonne est incluse dans un index ou lorsque vous avez créé manuellement un objet de statistiques pour la colonne. J'ai écrit un article de blog montrant l'erreur qui se présente lors de la tentative de modification d'une colonne avec un objet de statistiques créé manuellement. La même sémantique s'applique lors de la suppression d'une colonne - si la colonne est référencée par tout autre objet, il ne peut pas être simplement supprimé. L'objet de référence doit d'abord être modifié, puis la colonne peut être supprimée.

C'est assez facile à montrer en regardant le contenu du journal des transactions après avoir supprimé une colonne. Le code ci-dessous crée une table avec une seule colonne de 8 000 caractères longs. Il ajoute une ligne, puis la supprime et affiche le contenu du journal des transactions applicable à l'opération de suppression. Les enregistrements du journal montrent les modifications apportées à diverses tables système dans lesquelles les définitions de table et de colonne sont stockées. Si les données de la colonne étaient réellement supprimées des pages allouées à la table, vous verriez des enregistrements de journal enregistrant les données de page réelles, il n'y a pas de tels enregistrements.

(La sortie est trop grande pour être affichée ici, et dbfiddle.uk ne me permettra pas d'accéder à fn_dblog)

Le premier ensemble de sorties affiche le journal suite à la suppression de la colonne par l'instruction DDL. Le deuxième ensemble de résultats affiche le journal après l'exécution de l'instruction DML où nous mettons à jour la colonne rid. Dans le deuxième jeu de résultats, nous voyons des enregistrements de journal indiquant une suppression par rapport à dbo.DropColumnTest, suivie d'une insertion dans dbo.DropColumnTest. Chaque longueur d'enregistrement de journal est de 8116, indiquant que la page réelle a été mise à jour.

Comme vous pouvez le voir à partir de la sortie de la commande fn_dblog dans le test ci-dessus, l'ensemble de l'opération est entièrement connecté. Cela vaut pour la récupération simple, ainsi que pour la récupération complète. La terminologie "entièrement enregistré" peut être mal interprétée car la modification des données n'est pas enregistrée. Ce n'est pas ce qui se passe - la modification est enregistré et peut être entièrement annulé. Le journal est simplement seulement enregistrant les pages qui ont été touchées, et comme aucune des pages de données de la table n'a été enregistrée par l'opération DDL, la DROP COLUMN et toute annulation qui pourrait se produire se produiront extrêmement rapidement, quelle que soit la taille de la table.

Pour la science, le code suivant videra les pages de données pour la table incluse dans le code ci-dessus, en utilisant DBCC PAGE , style "3". Le style "3" indique que nous voulons l'en-tête de page ainsi qu'une interprétation détaillée par ligne. Le code utilise un curseur pour afficher les détails de tous page dans le tableau, vous pouvez donc vous assurer de ne pas l'exécuter sur un grand tableau.

En regardant la sortie de la première page de ma démo (après la suppression de la colonne, mais avant la mise à jour de la colonne), je vois ceci :

J'ai supprimé la plupart du vidage de la page brute de la sortie indiquée ci-dessus par souci de concision. À la fin de la sortie, vous verrez ceci pour la colonne rid :

La dernière ligne ci-dessus, rid = 1 , renvoie le nom de la colonne et la valeur actuelle stockée dans la colonne de la page.

La sortie montre que l'emplacement 0 contient une colonne supprimée, en raison du texte SUPPRIMÉ où se trouverait normalement le nom de la colonne. La valeur de la colonne est renvoyée comme NULL puisque la colonne a été supprimée. Cependant, comme vous pouvez le voir dans les données brutes, la valeur de 8 000 caractères, REPLICATE('Z', 8000) , pour cette colonne existe toujours sur la page. Voici un exemple de cette partie de la sortie DBCC PAGE :


4 réponses 4

L'option #2, en utilisant des tables de référence, est la façon standard de le faire. Il a été utilisé par des millions de programmeurs et est connu pour fonctionner. C'est un modèle, ainsi toute autre personne qui regarde vos affaires saura immédiatement ce qui se passe. Il existe des bibliothèques et des outils qui fonctionnent sur les bases de données, vous épargnant beaucoup, beaucoup de travail, qui le géreront correctement. Les avantages de son utilisation sont innombrables.

Est-ce du gaspillage ? Oui, mais seulement légèrement. Toute base de données à moitié décente gardera toujours en cache ces petites tables fréquemment jointes, de sorte que le gaspillage est généralement imperceptible.

Toutes les autres options que vous avez décrites sont ad hoc et bidon, y compris MySQL's enum , car elle ne fait pas partie de la norme SQL. (En dehors de cela, ce qui craint avec enum, c'est l'implémentation de MySQL, pas l'idée elle-même. Cela ne me dérangerait pas de le voir un jour dans le cadre de la norme.)

Votre dernière option n ° 3 avec l'utilisation d'un entier simple est surtout hacker. Vous obtenez le pire de tous les mondes : aucune intégrité référentielle, aucune valeur nommée, aucune connaissance définitive dans la base de données de ce que représente une valeur, juste des entiers arbitraires jetés partout. De ce fait, vous pouvez aussi bien arrêter d'utiliser des constantes dans votre code et commencer à utiliser des valeurs codées en dur à la place. circonférence = rayon * 6.28318530718 . Et ça ?

Je pense que vous devriez réexaminer pourquoi vous trouvez les tables de référence onéreuses. Pour autant que je sache, personne d'autre ne les trouve onéreux. Serait-ce parce que vous n'utilisez pas les bons outils pour le travail ?

Votre phrase sur le fait de devoir "coder des choses et traiter des nombres entiers", ou de devoir "créer des constructions de programmation élaborées", ou "créer de nouvelles entités orientées objet du côté de la programmation", me dit que vous essayez peut-être de faire de la relation objet mapping (ORM) à la volée dispersé dans tout le code de votre application, ou dans le meilleur des cas, vous essayez peut-être de déployer votre propre mécanisme de mappage objet-relationnel, au lieu d'utiliser un outil ORM existant pour le travail, tel que Hibernate. Toutes ces choses sont un jeu d'enfant avec Hibernate. Cela prend un peu de temps pour l'apprendre, mais une fois que vous l'avez appris, vous pouvez vraiment vous concentrer sur le développement de votre application et oublier la mécanique de base de la façon de représenter des éléments sur la base de données.

Enfin, si vous voulez vous simplifier la vie en travaillant directement avec la base de données, il y a au moins deux choses que vous pouvez faire, auxquelles je peux penser dès maintenant :

Créez des vues qui joignent vos tables principales avec les tables de référence auxquelles elles font référence, de sorte que chaque ligne contienne non seulement les identifiants de référence, mais également les noms correspondants.

Au lieu d'utiliser un identifiant entier pour la table de référence, utilisez une colonne CHAR(4), avec des abréviations à 4 lettres. Ainsi, les identifiants de vos catégories deviendraient "TEST", "DSGN", "PROG", "OTHR". (Leur descriptif resteraient des mots anglais corrects, bien sûr.) Ce sera un peu plus lent, mais croyez-moi, personne ne le remarquera.

Enfin, lorsqu'il n'y a que deux types, la plupart des gens utilisent simplement une colonne booléenne. Ainsi, cette colonne "standard/exception" serait implémentée comme un booléen et elle s'appellerait "IsException".


Limites des tableaux

Les tables BigQuery sont soumises aux limitations suivantes :

  • Les noms de table doivent être uniques par ensemble de données.
  • Cloud Console prend en charge la copie d'une seule table à la fois.
  • Lorsque vous copiez des tables, l'ensemble de données de destination doit résider au même emplacement que la table en cours de copie. Par exemple, vous ne pouvez pas copier une table d'un jeu de données basé dans l'UE vers un jeu de données basé aux États-Unis.
  • Lorsque vous copiez plusieurs tables source vers une table de destination à l'aide de l'outil de ligne de commande bq, de l'API ou des bibliothèques clientes, toutes les tables source doivent avoir des schémas identiques.
  • Lorsque vous exportez des données de table, la seule destination prise en charge est Cloud Storage.
  • Lorsque vous utilisez un appel d'API, les performances d'énumération ralentissent à mesure que vous approchez des 50 000 tables dans un ensemble de données.
  • Cloud Console peut afficher jusqu'à 50 000 tables pour chaque ensemble de données.

2 réponses 2

Pas dans une seule instruction, vous devrez déplacer le curseur autour des tables et générer du SQL dynamique pour vérifier chacune à son tour quelque chose comme ceci :

Le premier curseur est similaire à votre requête, la seule différence significative étant qu'il vérifie "il n'y a pas de colonnes qui ne sont pas nullable" au lieu de "il y en a qui sont nullables" car s'il y a au moins une colonne non nullable, vous ne pouvez pas avoir de lignes sans valeurs non NULL (si vous devez répertorier les tables avec des colonnes non nullables mais aucune ligne , car ils ont zéro ligne avec des valeurs non nulles, vous devez apporter quelques modifications à ce qui précède).

Dans la boucle passant par le curseur, nous utilisons du SQL dynamique pour ajouter le nombre de lignes de la table à notre magasin temporaire, puis le curseur interne rassemble un SQL plus dynamique qui ajoute à cela le nombre de lignes sans valeurs non NULL. Ajoutez PRINT @SQL avant EXEC (@SQL) pour voir ce que cela produit pour chaque table (ou à la place de l'appel à EXEC si vous voulez juste voir le code sans l'exécuter).

Cela va prendre un certain temps à s'exécuter sur des tables avec beaucoup de lignes car il fera presque certainement un balayage de table sur chaque table candidate.

REMARQUE : une table contenant tous les NULL implique qu'elle n'a pas de clé primaire (car celles-ci doivent être définies sur des colonnes qui ne peuvent pas être NULL), ce qui suggère que vous avez un problème de conception de base de données quelque part.

REMARQUE : si vous utilisez SQL Server 2017 ou une version ultérieure, vous pouvez remplacer le curseur interne créant le SQL dynamique par une seule requête à l'aide de STRING_AGG() . En fait, pour les versions précédentes, vous pouvez utiliser le hack "normal" FOR XML pour effectuer une concaténation similaire et éviter le curseur interne, bien que cela n'améliorerait pas la clarté autant que le simple GROUP ing et l'utilisation de STRING_AGG() le feraient.


6 réponses 6

Vous pouvez utiliser xts. indexmon. La création d'un objet xts est similaire à la création d'un objet zoo. En supposant que xData soit votre objet xts, quelque chose comme xData[.indexmon(xData) %in% c(5,6,7)] devrait faire ce que vous voulez.

Une option consiste à utiliser la fonction cycle() qui donne la position dans le cycle de chaque observation. Par exemple:

Ensuite, pour sous-ensemble d'un mois particulier, utilisez l'index de ce mois :

Je dois noter que cela renvoie un vecteur numérique, qui peut ou non être un problème pour vous en fonction de ce que vous voulez faire à partir de là. Je suis également curieux de voir d'autres solutions.

Vous pouvez extraire les mois de votre colonne jour/mois/année dans une nouvelle colonne appelée "mois" en utilisant substring(), par exemple,

Cela devrait créer une colonne qui ne contient que les mois.

puis sous-ensemble basé sur les valeurs de $month

Merci beaucoup pour votre aide. Permettez-moi d'écrire les trois solutions qui fonctionnent pour moi.

La première est la réponse de Joshua Ulrich :

Lire les données, créer un objet xts et utiliser indexmon

Voici un tracé de mdat

La deuxième solution provient de la liste de diffusion espagnole R et utilise le package lubridate :

L'intrigue de dataz :

Et le dernier également de la liste de diffusion espagnole, il utilise POSIXct pour prendre en compte à la fois la date et l'heure


4 réponses 4

Si les requêtes se trouvent dans des procédures stockées, ou si vous pouvez les placer dans une base de données temporaire en tant que procédures stockées, le SP système sp_depends et les vues de catalogue associées seront utiles. À tout le moins, ils affineront la recherche.

Si les requêtes sont dans des fichiers, un peu de Powershell générera des SP en un rien de temps.

S'ils sont intégrés dans l'application ou, Dieu merci, générés dynamiquement au moment de l'exécution d'un test de régression de l'application, la capture du SQL soumis et la procédure ci-dessus peuvent fonctionner.

Nous avons eu du succès avec une bibliothèque d'analyse .Net SQL. Son nom m'échappe pour l'instant. Si je le trouve, je le modifierai dans cette réponse. Vous devrez bien sûr toujours extraire le code SQL de votre application.

pas une solution "prête à l'emploi", mais c'est peut-être ce dont vous avez besoin : http://www.sqlparser.com

comme je l'explique en commentaire, c'est un framework, ce n'est pas une solution prête à l'emploi, mais il a un très bon ensemble d'exemples de code, ainsi qu'une démo en direct.

Vous déclarez que "certains des colonnes et des tableaux peuvent être renommés ou disparaître complètement. » J'interpréterais le corollaire à cela : plus des colonnes et des tableaux restent tels qu'ils étaient.

Par conséquent, en supposant que l'évaluation est correcte, plutôt que d'essayer d'identifier tout, vous devez créer une base de données de test pour apporter les modifications.

Restaurez une copie de votre base de données et nommez-la [Databasename_RevisionTest] . Effectuez ensuite vos modifications dans la base de données de test.

Une fois que vous avez modifié les tables, les vues (et les alias ?), utilisez un logiciel pour comparer les tables de [Databasename] avec [Databasename_RevisionTest] et signalez les modifications.

Il existe de nombreux outils pour comparer. Il se trouve que j'utilise SQL Compare de Red Gate, mais il existe de nombreux autres produits. Je vois même un outil de comparaison « gratuit » sur http://dbcomparer.com/.

L'utilisation d'un tel outil peut rapporter toutes les modifications apportées et pourrait simplifier votre travail en vous concentrant uniquement sur ce qui a changé.

Bien sûr, vous voudrez modifier votre code pour qu'il corresponde aux nouvelles définitions de table et de colonne. Une méthode simple mais fastidieuse consiste à coller le code (scripts, procédures stockées, etc.) dans le volet Requête SSMS et exécuter la commande Requête / Analyse.

Je n'ai pas utilisé le projet de code, mais peut-être que vous le trouverez utile.

ÉDITER: J'avais suggéré une copie de la base de données, mais comme les métadonnées sont tout ce qui est nécessaire pour votre test, l'organisation serait peut-être disposée à créer une base de données [Databasename_RevisionTest] qui ne contient aucune donnée.


10 réponses 10

Pensez à ce que vous obtenez en retour et à la manière dont vous les liez aux variables de votre code.

Maintenant, pensez à ce qui se passe lorsque quelqu'un met à jour le schéma de la table pour ajouter (ou supprimer) une colonne, même celle que vous n'utilisez pas directement.

L'utilisation de select * lorsque vous tapez des requêtes à la main est très bien, pas lorsque vous écrivez des requêtes pour le code.

Changements de schéma

  • Récupérer par ordre --- Si le code récupère la colonne # comme moyen d'obtenir les données, une modification du schéma entraînera un réajustement des numéros de colonne. Cela va gâcher l'application et de mauvaises choses vont arriver.
  • Récupérer par nom --- Si le code récupère une colonne par nom , comme foo , et qu'une autre table dans la requête ajoute une colonne foo , la façon dont cela est géré peut causer des problèmes lors de la tentative d'obtention du droite colonne foo.

Dans tous les cas, une modification de schéma peut entraîner des problèmes d'extraction des données.

Considérez en outre si une colonne qui était utilisée est supprimé de la table. La sélection * à partir de . fonctionne toujours mais des erreurs se produisent lorsque vous essayez d'extraire les données de l'ensemble de résultats. Si la colonne est spécifiée dans la requête, le mettre en doute se trompera à la place en donnant une indication claire de la nature et de l'endroit du problème.

Frais généraux de données

Certaines colonnes peuvent être associées à une quantité importante de données. La sélection de retour * tirera tous les données. Oui, voici ce varchar (4096) sur 1 000 lignes que vous avez sélectionnées, ce qui vous donne 4 mégaoctets supplémentaires de données dont vous n'avez pas besoin, mais qui est quand même envoyé sur le fil.

Lié au changement de schéma, ce varchar n'existe peut-être pas là lorsque vous avez créé la table pour la première fois, mais il est maintenant là.

Défaut de transmettre l'intention

Lorsque vous sélectionnez Retour * et obtenez 20 colonnes mais que vous n'en avez besoin que de 2, vous ne transmettez pas l'intention du code. Lorsque l'on regarde la requête qui effectue une sélection *, on ne sait pas quelles sont les parties importantes de celle-ci. Puis-je modifier la requête pour utiliser cet autre plan à la place pour le rendre plus rapide en n'incluant pas ces colonnes ? Je ne sais pas parce que l'intention de ce que la requête renvoie n'est pas claire.

Regardons quelques violons SQL qui explorent ces changements de schéma un peu plus.

Et les colonnes que vous obtenez sont oneid=1 , data=42 , twoid=2 et other=43 .

Maintenant, que se passe-t-il si j'ajoute une colonne au tableau 1 ? http://sqlfiddle.com/#!2/cd0b0/1

Et mes résultats de la même requête qu'auparavant sont oneid=1 , data=42 , twoid=2 et other=foo .

Un changement dans l'une des tables perturbe les valeurs d'un select * et soudainement votre liaison de 'other' à un int va générer une erreur et vous ne savez pas pourquoi.

Si à la place votre instruction SQL était

La modification de la table 1 n'aurait pas perturbé vos données. Cette requête s'exécute de la même manière avant la modification et après la modification.

Indexage

Lorsque vous faites une sélection * de vous tirez tous les lignes forment tous les tables qui correspondent aux conditions. Même les tables dont vous ne vous souciez vraiment pas. Bien que cela signifie que davantage de données sont transférées, un autre problème de performances se cache plus loin dans la pile.

Si vous retirez beaucoup de colonnes, l'optimiseur de plan de base de données mai ne tenez pas compte de l'utilisation d'un index, car vous devrez quand même récupérer toutes ces colonnes et cela prendrait plus de temps pour utiliser l'index, puis récupérer toutes les colonnes de la requête que pour effectuer simplement une analyse complète de la table.

Si vous ne faites que sélectionner le nom de famille d'un utilisateur (ce que vous faites beaucoup et que vous avez donc un index dessus), la base de données peut effectuer une analyse d'index uniquement (analyse d'index postgres wiki uniquement, analyse complète de la table mysql vs complète analyse d'index, analyse d'index uniquement : éviter l'accès aux tables).

Il y a pas mal d'optimisations sur la lecture uniquement à partir des index si possible. Les informations peuvent être extraites plus rapidement sur chaque page d'index car vous en extrayez également moins - vous n'extrayez pas toutes ces autres colonnes pour le select * . Il est possible qu'une analyse d'index uniquement renvoie des résultats de l'ordre de 100x plus rapide (source : Sélectionnez * est mauvais).

Cela ne veut pas dire qu'une analyse complète de l'index est excellente, c'est toujours une analyse complète - mais c'est mieux qu'une analyse complète de la table. Une fois que vous commencez à rechercher toutes les façons dont cette sélection * nuit aux performances, vous continuez à en trouver de nouvelles.

Lecture connexe

Autre souci : s'il s'agit d'une requête JOIN et que vous récupérez les résultats de la requête dans un tableau associatif (comme cela pourrait être le cas en PHP), c'est sujet aux bugs.

  1. si la table foo a des colonnes id et name
  2. si la barre de table a des colonnes id et address ,
  3. et dans votre code, vous utilisez SELECT * FROM foo JOIN bar ON foo.id = bar.id

devinez ce qui se passe lorsque quelqu'un ajoute un nom de colonne à la table à barres.

Le code cessera soudainement de fonctionner correctement, car maintenant la colonne de nom apparaît dans les résultats à deux reprises et si vous stockez les résultats dans un tableau, les données du deuxième nom ( bar.name ) écraseront le prénom ( foo.name ) !

C'est un bug assez méchant car il n'est pas évident. Cela peut prendre un certain temps à comprendre, et il est impossible que la personne qui ajoute une autre colonne au tableau ait pu anticiper un effet secondaire aussi indésirable.

Donc, n'utilisez pas * , contrôlez les colonnes que vous récupérez et utilisez des alias le cas échéant.

Interroger chaque colonne peut être parfaitement légitime, dans de nombreux cas.

Toujours l'interrogation de chaque colonne ne l'est pas.

C'est plus de travail pour votre moteur de base de données, qui doit partir et fouiller dans ses métadonnées internes pour déterminer les colonnes qu'il doit traiter avant de pouvoir se consacrer à la véritable tâche consistant à récupérer les données et à vous les renvoyer. OK, ce n'est pas le plus gros surcoût au monde, mais les catalogues système peuvent être un goulot d'étranglement appréciable.

C'est plus de travail pour votre réseau, parce que vous vous retirez n'importe quel chiffre de champs alors que vous n'en voulez peut-être qu'un ou deux. Si quelqu'un [d'autre] ajoute quelques douzaines de champs supplémentaires, qui contiennent tous de gros morceaux de texte, votre débit passe soudainement par le sol - sans raison apparente. Cela est aggravé si votre clause "où" n'est pas particulièrement bonne et que vous retirez également beaucoup de lignes - c'est potentiellement beaucoup de données qui se frayent un chemin à travers le réseau jusqu'à vous (c'est-à-dire que ça va être lent).

C'est plus de travail pour votre application, de devoir retirer et stocker toutes ces données supplémentaires dont elle ne se soucie probablement pas.

Vous courez le risque que les colonnes changent d'ordre. OK, vous ne devriez pas avoir à vous en soucier (et vous habitude si vous ne sélectionnez que les colonnes dont vous avez besoin) mais, si vous les récupérez toutes en même temps et que quelqu'un [d'autre] décide de réorganiser l'ordre des colonnes dans le tableau, cette exportation CSV soigneusement conçue que vous donnez aux comptes au bout du couloir disparaît soudainement tout en pot - encore une fois, sans raison apparente.

BTW, j'ai dit "quelqu'un [d'autre]" plusieurs fois, ci-dessus. N'oubliez pas que les bases de données sont intrinsèquement multi-utilisateurs, vous n'avez peut-être pas le contrôle sur elles que vous pensez avoir.


"sklearn.datasets" est un package scikit, où il contient une méthode load_iris().

load_iris(), renvoie par défaut un objet qui contient données, cible et d'autres membres en elle. Pour obtenir les valeurs réelles, vous devez lire le données et cible contenu lui-même.

Alors que 'iris.csv' maintient la fonctionnalité et la cible ensemble.

POUR VOTRE INFORMATION: Si vous définissez return_X_y comme True dans load_iris(), alors vous obtiendrez directement les fonctionnalités et la cible.

Si votre deuxième programme d'extrait de code a été exécuté (en continuation) sur le même noyau que celui sur lequel vous avez exécuté le premier programme d'extrait de code, vous obtiendrez cette erreur car l'iris de l'ensemble de données a été prédéfini par vous et contient déjà des données de méthode, fournies par Scikit- Apprendre.

Lorsque vous travaillez avec des CSV des dossiers, Pandas avez différentes méthodes que vous pouvez utiliser, telles que :

Veuillez confirmer si votre programme a récupéré cette erreur ou des noyaux séparés. Ou bien, si cette solution correspond à vos besoins, vous pouvez choisir de la marquer comme réponse pour que les autres apprenants en bénéficient en cas de doute.

Lorsque nous chargeons les données d'iris directement à partir des ensembles de données sklearn, nous n'avons pas à nous soucier de découper les colonnes pour les données et la cible, car sklearn lui-même aurait organisé les données de manière à pouvoir les utiliser directement pour alimenter le modèle.

Mais lorsque nous chargeons à partir des données du fichier csv, nous devons découper les colonnes selon nos besoins et les organiser de manière à pouvoir les intégrer dans le modèle. Lorsque vous exécutez les lignes ci-dessous après avoir lu le fichier csv en utilisant read_csv dans les pandas

vous faites en fait référence aux attributs du cadre de données pandas et non aux données réelles et aux valeurs de la colonne cible comme dans sklearn. Vous devrez utiliser iris['data'], iris['target'] pour accéder aux valeurs des colonnes si elles sont présentes dans l'ensemble de données.


Voir la vidéo: MapInfoDiscover Selecting u0026 Querying Data clip