Est-ce considéré comme un anti-modèle d'écrire SQL dans le code source?

Est-ce considéré comme un anti-modèle pour coder en dur le code SQL dans une application comme celle-ci:

public List<int> getPersonIDs()
{    
    List<int> listPersonIDs = new List<int>();
    using (SqlConnection connection = new SqlConnection(
        ConfigurationManager.ConnectionStrings["Connection"].ConnectionString))
    using (SqlCommand command = new SqlCommand())
    {
        command.CommandText = "select id from Person";
        command.Connection = connection;
        connection.Open();
        SqlDataReader datareader = command.ExecuteReader();
        while (datareader.Read())
        {
            listPersonIDs.Add(Convert.ToInt32(datareader["ID"]));
        }
    }
    return listPersonIDs;
}

J'aurais normalement une couche de référentiel, etc., mais je l'ai exclue dans le code ci-dessus pour des raisons de simplicité.

J'ai récemment eu des commentaires d'un collègue qui s'est plaint que SQL a été écrit dans le code source. Je n'ai pas eu l'occasion de demander pourquoi et il est maintenant absent pendant deux semaines (peut-être plus). Je suppose qu'il voulait dire soit:

1. Utilisez LINQ
   ou
2. Utiliser des procédures stockées pour le SQL

Ai-je raison? Est-ce considéré comme un anti-modèle d'écrire SQL dans le code source? Nous sommes une petite équipe travaillant sur ce projet. Je pense que l’avantage des procédures stockées est que les développeurs SQL peuvent s’impliquer dans le processus de développement (écriture de procédures stockées, etc.).

Modifier Le lien suivant concerne les instructions SQL codées en dur: https://docs.microsoft.com/en-us/sql/odbc/reference/develop-app/hard-coded-sql-statements . La préparation d'une instruction SQL présente-t-elle un avantage?

Vous avez exclu la partie cruciale pour la simplicité. Le référentiel est la couche d'abstraction pour la persistance. Nous séparons la persistance dans sa propre couche afin de pouvoir modifier plus facilement la technologie de persistance lorsque nous en avons besoin. Par conséquent, le fait que SQL se trouve en dehors de la couche de persistance empêche complètement d'avoir une couche de persistance séparée.

En conséquence, SQL convient à la couche de persistance propre à une technologie SQL (par exemple, SQL convient à a SQLCustomerRepositorymais pas à a MongoCustomerRepository). En dehors de la couche de persistance, SQL rompt votre abstraction et est donc considéré comme une très mauvaise pratique (par moi).

En ce qui concerne des outils tels que LINQ ou JPQL: Ceux-ci peuvent simplement résumer les variantes de SQL. Avoir des requêtes LINQ-Code ou JPQL en dehors d'un référentiel annule l'abstraction de la persistance autant que le ferait un SQL brut.

Un autre avantage considérable d’une couche de persistance distincte est qu’elle vous permet de désendetter votre code de logique métier sans avoir à configurer un serveur de base de données.

Vous obtenez des tests unitaires rapides avec un profil de mémoire faible et des résultats reproductibles sur toutes les plateformes prises en charge par votre langue.

Dans une architecture de service MVC +, il s’agit simplement de simuler l’instance de référentiel, de créer des données fictives en mémoire et de définir que le référentiel doit renvoyer ces données fictives lorsqu’un getter donné est appelé. Vous pouvez ensuite définir les données de test par test et ne plus avoir à nettoyer la base de données par la suite.

Le test des écritures dans la base de données est aussi simple: vérifiez que les méthodes de mise à jour appropriées sur la couche de persistance ont été appelées et assurez-vous que les entités étaient dans l'état correct lorsque cela s'est produit.

La plupart des applications métier standard actuelles utilisent différentes couches avec différentes responsabilités. Cependant, quelles couches vous utilisez pour votre application et quelle couche a la responsabilité qui vous revient, à vous et à votre équipe. Avant de pouvoir décider s'il est correct ou non de placer directement le code SQL dans la fonction que vous nous avez montrée, vous devez le savoir.

• quelle couche dans votre application a quelle responsabilité

• de quelle couche la fonction ci-dessus est de

Il n’existe pas de solution universelle. Dans certaines applications, les concepteurs préfèrent utiliser un framework ORM et laisser le framework générer tout le code SQL. Dans certaines applications, les concepteurs préfèrent stocker un tel SQL exclusivement dans des procédures stockées. Pour certaines applications, il existe une couche de persistance (ou référentiel) écrite à la main, où réside le code SQL. Pour d'autres applications, il est correct de définir des exceptions dans certaines circonstances en plaçant strictement le code SQL dans cette couche de persistance.

Vous devez donc réfléchir aux éléments suivants: quelles couches souhaitez- vous ou avez-vous besoin dans votre application particulière et comment souhaitez- vous assumer les responsabilités? Vous avez écrit "J'aurais normalement une couche de référentiel" , mais quelles sont les responsabilités exactes que vous souhaitez avoir à l'intérieur de cette couche et quelles responsabilités souhaitez-vous placer ailleurs? Répondez à cela en premier, vous pourrez alors répondre à votre question par vous-même.

Marstato donne une bonne réponse, mais j'aimerais ajouter quelques commentaires.

SQL dans la source n'est pas un anti-modèle, mais cela peut causer des problèmes. Je me souviens de l'époque où vous deviez placer des requêtes SQL dans les propriétés des composants déposés dans chaque formulaire. Cela rendait les choses vraiment très moche très vite et il fallait sauter à travers des cerceaux pour localiser les requêtes. Je suis devenu un ardent défenseur de la centralisation maximale de l'accès à la base de données dans les limites des langues avec lesquelles je travaillais. Votre collègue pourrait avoir des flash-back à ces jours sombres.

Maintenant, certains commentaires parlent du blocage des fournisseurs, comme si c'était automatiquement une mauvaise chose. Ce n'est pas. Si je signe un chèque à six chiffres chaque année pour utiliser Oracle, vous pouvez parier que je veux que toute application ayant accès à cette base de données utilise correctement la syntaxe Oracle supplémentairemais à son maximum. Je ne serais pas heureux si ma brillante base de données est paralysée par les codeurs qui écrivent mal le SQL ANSI vanille alors qu’il existe une "manière Oracle" d’écrire le code SQL qui ne paralyse pas la base de données. Oui, il sera plus difficile de modifier les bases de données, mais je ne l'ai vu faire que plusieurs fois en plus de 20 ans sur un grand site client. L'un de ces cas était celui de DB2 -> Oracle, car l'ordinateur central hébergeant DB2 était obsolète et mis hors service. . Oui, c’est le blocage du fournisseur, mais pour les entreprises, il est en fait souhaitable de payer pour un SGBDR capable et coûteux comme Oracle ou Microsoft SQL Server, puis de l’utiliser au maximum. Vous avez un contrat d'assistance comme couverture confortable. Si je paie pour une base de données avec une implémentation de procédure stockée riche,

Cela nous amène au point suivant: si vous écrivez une application qui accède à une base de données SQL, vous devez apprendre le SQL ainsi que l’autre langage. En apprenant, je veux aussi dire l’optimisation des requêtes; Je vais me fâcher contre vous si vous écrivez du code de génération SQL qui vide le cache SQL avec un barrage de requêtes presque identiques alors que vous auriez pu utiliser une requête intelligemment paramétrée.

Pas d'excuses, pas de cachettes derrière un mur d'Hibernate. Les ORM mal utilisés peuvent vraiment nuire aux performances des applications. Je me souviens avoir vu une question sur Stack Overflow il y a quelques années dans le sens de:

Dans Hibernate, nous parcourons 250 000 enregistrements en vérifiant les valeurs de quelques propriétés et en mettant à jour des objets correspondant à certaines conditions. C'est un peu lent, que puis-je faire pour l'accélérer?

Que diriez-vous de "table UPDATE SET champ1 = où champ2 est vrai et champ3> 100". La création et l'élimination de 250 000 objets pourraient bien être votre problème ...

Par exemple, Ignorez Hibernate lorsqu'il n'est pas approprié de l'utiliser. Comprendre la base de données.

Donc, en résumé, incorporer du SQL dans du code peut être une mauvaise pratique, mais il y a des choses bien pires que vous pouvez faire en essayant d'éviter l'incorporation de SQL.

Oui, coder en dur les chaînes SQL en code d'application est généralement un anti-motif.

Essayons de mettre de côté la tolérance que nous avons développée depuis des années à voir cela dans le code de production. Mélanger des langues complètement différentes avec une syntaxe différente dans le même fichier n'est généralement pas une technique de développement souhaitable. Cela diffère des modèles de langage comme Razor, conçus pour donner une signification contextuelle à plusieurs langues. Comme Sava B. le mentionne dans un commentaire ci-dessous, SQL en C # ou dans un autre langage d'application (Python, C ++, etc.) est une chaîne comme une autre et n'a aucune signification sémantique. La même chose s’applique lorsqu’on mélange plusieurs langues dans la plupart des cas, bien qu’il soit évident que cela est acceptable, comme assemblage en ligne en C, petits extraits compréhensibles de CSS en HTML (notant que CSS est conçu pour être mélangé avec HTML ), et d'autres.

(Robert C. Martin sur le mélange des langues, Clean Code , Chapitre 17, "Odeurs de code et heuristiques", page 288)

Pour cette réponse, je vais me concentrer sur SQL (comme demandé dans la question). Les problèmes suivants peuvent survenir lors du stockage de SQL en tant qu'ensemble à la carte de chaînes dissociées:

• La logique de la base de données est difficile à localiser. Que recherchez-vous pour trouver toutes vos instructions SQL? Des chaînes avec "SELECT", "UPDATE", "MERGE", etc.?
• Le refactoring utilise un SQL identique ou similaire devient difficile.
• L'ajout d'un support pour d'autres bases de données est difficile. Comment pourrait-on accomplir cela? Ajouter des instructions if..then pour chaque base de données et stocker toutes les requêtes sous forme de chaînes dans la méthode?
• Les développeurs lisent une déclaration dans une autre langue et sont distraits par le changement d'orientation de l'objectif de la méthode vers les détails de son implémentation (comment et à partir de l'endroit où les données sont récupérées).
• Bien que les un-lignes ne posent pas trop de problèmes, les chaînes SQL en ligne commencent à s'effriter à mesure que les instructions deviennent plus complexes. Que faites-vous avec une déclaration de 113 lignes? Mettez les 113 lignes dans votre méthode?
• Comment le développeur déplace-t-il efficacement les requêtes entre leur éditeur SQL (SSMS, SQL Developer, etc.) et leur code source? Le @préfixe C # facilite cela, mais j'ai vu beaucoup de code qui cite chaque ligne SQL et échappe aux nouvelles lignes. "SELECT col1, col2...colN"\ "FROM painfulExample"\ "WHERE maintainability IS NULL"\ "AND modification.effort > @necessary"\
• Les caractères d'indentation utilisés pour aligner le code SQL avec le code d'application environnant sont transmis sur le réseau à chaque exécution. Ceci est probablement insignifiant pour les applications à petite échelle, mais cela peut s’additionner à mesure que l’utilisation du logiciel se développe.

Les ORM complets (mappeurs objet-relationnels tels qu'Entity Framework ou Hibernate) peuvent éliminer le code SQL modifié au hasard. Mon utilisation de SQL et des fichiers de ressources n’est qu’un exemple. Les ORM, les classes d'assistance, etc. peuvent tous contribuer à atteindre l'objectif d'un code plus propre.

Comme Kevin l'a dit dans une réponse précédente, le code SQL peut être acceptable dans les petits projets, mais les grands projets démarrent sous la forme de petits projets et la probabilité que la plupart des équipes y reviennent et le fasse correctement est souvent inversement proportionnelle à la taille du code.

Il existe de nombreuses manières simples de conserver SQL dans un projet. L’une des méthodes que j’utilise souvent est de placer chaque instruction SQL dans un fichier de ressources Visual Studio, généralement nommé "sql". Un fichier texte, un document JSON ou une autre source de données peut être raisonnable en fonction de vos outils. Dans certains cas, une classe distincte dédiée à l'enchaînement de chaînes SQL peut être la meilleure option, mais peut présenter certains des problèmes décrits ci-dessus.

Exemple SQL: Qu'est-ce qui semble plus élégant?

using(DbConnection connection = Database.SystemConnection()) {
    var eyesoreSql = @"
    SELECT
        Viewable.ViewId,
        Viewable.HelpText,
        PageSize.Width,
        PageSize.Height,
        Layout.CSSClass,
        PaginationType.GroupingText
    FROM Viewable
    LEFT JOIN PageSize
        ON PageSize.Id = Viewable.PageSizeId
    LEFT JOIN Layout
        ON Layout.Id = Viewable.LayoutId
    LEFT JOIN Theme
        ON Theme.Id = Viewable.ThemeId
    LEFT JOIN PaginationType
        ON PaginationType.Id = Viewable.PaginationTypeId
    LEFT JOIN PaginationMenu
        ON PaginationMenu.Id = Viewable.PaginationMenuId
    WHERE Viewable.Id = @Id
    ";
    var results = connection.Query<int>(eyesoreSql, new { Id });
}

Devient

using(DbConnection connection = Database.SystemConnection()) {
    var results = connection.Query<int>(sql.GetViewable, new { Id });
}

Le code SQL se trouve toujours dans un fichier ou un ensemble de fichiers facile à localiser, chacun avec un nom descriptif qui décrit ce qu'il fait plutôt que comment il le fait, chacun avec de la place pour un commentaire qui n'interrompra pas le flux de code d'application :

Cette méthode simple exécute une requête solitaire. D'après mon expérience, les avantages sont proportionnels à l'utilisation de la "langue étrangère". Mon utilisation d'un fichier de ressources n'est qu'un exemple. Différentes méthodes peuvent être plus appropriées en fonction du langage (SQL dans ce cas) et de la plate-forme.

Ceci et d'autres méthodes résolvent la liste ci-dessus de la manière suivante:

1. Le code de base de données est facile à localiser car il est déjà centralisé. Dans les projets plus importants, regroupez like-SQL dans des fichiers distincts, éventuellement dans un dossier nommé SQL.
2. Le support pour une deuxième, troisième, etc. bases de données est plus facile. Créez une interface (ou une autre abstraction de langage) qui renvoie les instructions uniques de chaque base de données. L'implémentation de chaque base de données devient un peu plus que des instructions similaires à: return SqlResource.DoTheThing;True, ces implémentations peuvent ignorer la ressource et contenir le code SQL dans une chaîne, mais certains problèmes (mais pas tous) mentionnés ci-dessus ne feraient que surface.
3. Le refactoring est simple: il suffit de réutiliser la même ressource. Vous pouvez même utiliser la même entrée de ressource pour différents systèmes de SGBD avec quelques instructions de format. Je le fais souvent.
4. L’utilisation de la langue secondaire peut utiliser des noms descriptifs , par exemple sql.GetOrdersForAccountplutôt que plus obtusSELECT ... FROM ... WHERE...
5. Les instructions SQL sont appelées avec une ligne, quelles que soient leur taille et leur complexité.
6. Le code SQL peut être copié et collé entre des outils de base de données tels que SSMS et SQL Developer, sans modification ni copie soigneuse. Pas de guillemets. Pas de barres obliques inverses. Dans le cas de l'éditeur de ressources Visual Studio en particulier, un clic met en surbrillance l'instruction SQL. CTRL + C puis collez-le dans l'éditeur SQL.

La création de SQL dans une ressource est rapide, il y a donc peu d’impulsion pour combiner l’utilisation des ressources avec SQL dans le code.

Quelle que soit la méthode choisie, j'ai constaté que le mélange de langages réduisait généralement la qualité du code. J'espère que certains problèmes et solutions décrits ici aideront les développeurs à éliminer cette odeur de code, le cas échéant.

Ça dépend. Un certain nombre d'approches différentes peuvent fonctionner:

1. Modularisez le code SQL et isolez-le dans un ensemble séparé de classes, de fonctions ou de toute unité d'abstraction utilisée par votre paradigme, puis appelez-le avec la logique d'application.
2. Déplacez tout le SQL complexe dans les vues, puis ne créez que du SQL très simple dans la logique de l'application, de sorte que vous n'avez pas besoin de modulariser.
3. Utilisez une bibliothèque de mappage relationnel-objet.
4. YAGNI, il suffit d'écrire SQL directement dans la logique de l'application.

Comme c'est souvent le cas, si votre projet a déjà choisi l'une de ces techniques, vous devez être cohérent avec le reste du projet.

(1) et (3) maintiennent relativement bien l'indépendance entre la logique de l'application et la base de données, en ce sens que l'application continuera à compiler et à réussir les tests de fumée de base si vous remplacez la base de données par un autre fournisseur. Cependant, la plupart des fournisseurs ne se conformant pas totalement à la norme SQL, leur remplacement par un autre fournisseur nécessitera probablement des tests et une recherche de bogues approfondis, quelle que soit la technique utilisée. Je suis sceptique quant à la pertinence de cet accord. Changer de base de données est fondamentalement un dernier recours lorsque vous ne pouvez pas obtenir la base de données actuelle pour répondre à vos besoins. Si cela se produit, vous avez probablement mal choisi la base de données.

Le choix entre (1) et (3) dépend principalement de votre goût pour les ORM. À mon avis, ils sont trop utilisés. Ils représentent mal le modèle de données relationnel, car les lignes n'ont pas d'identité de la même manière que les objets. Vous rencontrerez probablement des problèmes avec des contraintes uniques, des jointures, et vous aurez peut-être de la difficulté à exprimer des requêtes plus complexes en fonction de la puissance de l'ORM. D'autre part, (1) nécessitera probablement beaucoup plus de code qu'un ORM.

(2) est rarement vu, dans mon expérience. Le problème est que beaucoup de magasins interdisent aux entreprises de taille moyenne de modifier directement le schéma de la base de données (car "c'est le travail du DBA"). Ce n'est pas nécessairement une mauvaise chose en soi; Les modifications de schéma ont un potentiel important de rupture et doivent être déployées avec précaution. Toutefois, pour que (2) fonctionne, les SWE doivent au moins pouvoir introduire de nouvelles vues et modifier les requêtes de sauvegarde des vues existantes avec une bureaucratie minimale ou nulle. Si ce n'est pas le cas sur votre lieu de travail, (2) ne fonctionnera probablement pas pour vous.

D'un autre côté, si vous pouvez obtenir (2) de fonctionner, c'est beaucoup mieux que la plupart des autres solutions, car la logique relationnelle est conservée dans SQL plutôt que dans le code de l'application. Contrairement aux langages de programmation d'usage général, SQL est spécialement conçu pour le modèle de données relationnel et est par conséquent plus apte à exprimer des requêtes et des transformations de données complexes. Les vues peuvent également être portées avec le reste de votre schéma lors du changement de bases de données, mais elles rendront ces déplacements plus compliqués.

Pour les lectures, les procédures stockées ne sont fondamentalement qu'une version plus déplorable de (2). Je ne les recommande pas en cette qualité, mais vous pouvez toujours les vouloir pour les écritures, si votre base de données ne prend pas en charge les vues pouvant être mises à jour , ou si vous devez effectuer quelque chose de plus complexe que l'insertion ou la mise à jour d'une seule ligne à la fois (par exemple, transactions, lecture / écriture, etc.). Vous pouvez coupler votre procédure stockée à une vue à l'aide d'un déclencheur (c'est-à-direCREATE TRIGGER trigger_name INSTEAD OF INSERT ON view_name FOR EACH ROW EXECUTE PROCEDURE procedure_name;), mais les opinions varient considérablement quant à savoir s’il s’agit réellement d’une bonne idée. Les promoteurs vous diront qu'il conserve le code SQL que votre application exécute aussi simple que possible. Les détracteurs vous diront qu'il s'agit d'un niveau de "magie" inacceptable et que vous devez simplement exécuter la procédure directement à partir de votre application. Je dirais que cela est une meilleure idée si votre procédure stockée ressemble ou agit beaucoup comme un INSERT, UPDATEou DELETE, et une idée pire si elle est en train de faire autre chose. En fin de compte, vous devrez décider vous-même quel style a le plus de sens.

(4) est la non-solution. Cela peut valoir la peine pour de petits projets ou de grands projets qui n'interagissent que sporadiquement avec la base de données. Toutefois, pour les projets contenant beaucoup de SQL, ce n'est pas une bonne idée car vous pouvez avoir des doublons ou des variantes de la même requête éparpillés au hasard dans votre application, ce qui nuit à la lisibilité et au refactoring.

Est-ce considéré comme un anti-modèle d'écrire SQL dans le code source?

Pas nécessairement. Si vous lisez tous les commentaires ici, vous trouverez des arguments valides pour coder en dur les instructions SQL dans le code source.

Le problème vient de l'endroit où vous placez les déclarations . Si vous placez les instructions SQL dans tout le projet, partout, vous ignorerez probablement certains des principes SOLID que nous nous efforçons généralement de suivre.

supposons qu'il voulait dire; Soit:

1) Utilisez LINQ

ou

2) Utiliser des procédures stockées pour le SQL

Nous ne pouvons pas dire ce qu'il voulait dire. Cependant, on peut deviner. Par exemple, le premier qui me vienne à l’esprit est le blocage des fournisseurs . Les instructions SQL codées en dur peuvent vous amener à coupler étroitement votre application au moteur de base de données. Par exemple, en utilisant des fonctions spécifiques du fournisseur qui ne sont pas compatibles ANSI.

Ce n'est pas nécessairement faux ni mauvais. Je montre simplement le fait.

Ignorer les principes SOLID et les verrous des vendeurs peut avoir des conséquences négatives que vous pourriez ignorer. C'est pourquoi il est généralement bon de s'asseoir avec l'équipe et d'exposer ses doutes.

Je pense que l’avantage des procédures stockées est que les développeurs SQL peuvent s’impliquer dans le processus de développement (écriture de procédures stockées, etc.)

Je pense que cela n'a rien à voir avec les avantages des procédures stockées. De plus, si votre collègue n'aime pas le code SQL codé en dur, il est probable que le fait de déplacer l'entreprise vers des procédures stockées ne l'aimera pas davantage.

Edit: le lien suivant concerne les instructions SQL codées en dur:  https://docs.microsoft.com/en-us/sql/odbc/reference/develop-app/hard-coded-sql-statements . La préparation d'une instruction SQL présente-t-elle un avantage?

Oui. La poste énumère les avantages des déclarations préparées . C'est une sorte de template SQL. Plus sécurisé que la concaténation de chaînes. Mais le message ne vous encourage pas à aller dans cette direction et ne confirme pas que vous avez raison. Il explique simplement comment utiliser SQL codé en dur de manière sûre et efficace.

Pour résumer, essayez d'abord de demander à votre collègue. Envoyez un mail, téléphonez-lui, ... Qu'il réponde ou non, asseyez-vous avec l'équipe et exposez vos doutes. Trouvez la solution qui répond le mieux à vos besoins. Ne faites pas de fausses hypothèses en vous basant sur ce que vous avez lu.

Je pense que c'est une mauvaise pratique, oui. D'autres ont souligné les avantages de garder tous vos codes d'accès aux données dans leur propre couche. Vous n'avez pas à chercher, il est plus facile d'optimiser et de tester ... Mais même au sein de cette couche, vous avez plusieurs choix: utiliser un ORM, utiliser des sprocs ou incorporer des requêtes SQL sous forme de chaînes. Je dirais que les chaînes de requête SQL sont de loin la pire option.

Avec un ORM, le développement devient beaucoup plus facile et moins sujet aux erreurs. Avec EF, vous définissez votre schéma simplement en créant vos classes de modèle (vous auriez quand même eu besoin de créer ces classes). Interroger avec LINQ est un jeu d'enfant - vous vous échappez souvent avec 2 lignes de c # où vous auriez autrement besoin d'écrire et de gérer un sproc. OMI, cela présente un avantage énorme en termes de productivité et de facilité de maintenance: moins de code, moins de problèmes. Mais il y a un surcoût lié aux performances, même si vous savez ce que vous faites.

Sprocs (ou fonctions) sont l'autre option. Ici, vous écrivez vos requêtes SQL manuellement. Mais au moins, vous avez la garantie qu'ils sont corrects. Si vous travaillez dans .NET, Visual Studio générera même des erreurs de compilateur si le code SQL n'est pas valide. C'est bien. Si vous modifiez ou supprimez une colonne et que certaines de vos requêtes deviennent invalides, au moins vous en saurez plus à ce sujet lors de la compilation. Il est également plus facile de conserver les fichiers sprocs dans leurs propres fichiers - vous obtiendrez probablement la coloration syntaxique, la saisie semi-automatique, etc.

Si vos requêtes sont stockées sous forme de sprocs, vous pouvez également les modifier sans recompiler ni déployer l'application. Si vous remarquez que quelque chose dans votre code SQL est cassé, un administrateur de base de données peut le réparer sans avoir besoin d'accéder à votre code d'application. En général, si vos requêtes sont exprimées en littéraux de chaîne, vous ne pouvez pas faire leur travail presque aussi facilement.

Les requêtes SQL en tant que littéraux de chaîne rendront également votre code c # d'accès aux données moins lisible.

En règle générale, les constantes magiques sont mauvaises. Cela inclut les littéraux de chaîne.

Ce n'est pas un anti-modèle (cette réponse est dangereusement proche de l'opinion). Mais le formatage du code est important, et la chaîne SQL doit être formatée de manière à être clairement séparée du code qui l’utilise. Par exemple

    string query = 
    @"SELECT foo, bar
      FROM table
      WHERE id = @tn";

Je ne peux pas vous dire ce que votre collègue voulait dire. Mais je peux répondre à ceci:

La préparation d'une instruction SQL présente-t-elle un avantage?

OUI . L'utilisation d'instructions préparées avec des variables liées constitue la défense recommandée contre l' injection SQL , qui reste le principal risque de sécurité pour les applications Web depuis plus de dix ans . Cette attaque est si courante qu’elle figurait dans les bandes dessinées web il y a près de dix ans et il est grand temps que des défenses efficaces soient déployées.

... et la défense la plus efficace contre la mauvaise concaténation des chaînes de requête ne consiste pas à représenter les requêtes sous forme de chaînes, mais à utiliser une API de requête de type sécurisé pour créer des requêtes. Par exemple, voici comment j'écrirais votre requête en Java avec QueryDSL:

List<UUID> ids = select(person.id).from(person).fetch();

Comme vous pouvez le constater, il n’existe pas un seul littéral de chaîne, ce qui rend impossible l’injection SQL. De plus, j’avais terminé le code lorsque j’écrivais cela, et mon IDE peut le refactoriser si je décidais de renommer la colonne id. De plus, je peux facilement trouver toutes les requêtes pour la table de personnes en demandant à mon IDE où la personvariable est consultée. Oh, et avez-vous remarqué que c'est beaucoup plus court et plus agréable pour les yeux que votre code?

Je ne peux que supposer que quelque chose comme ceci est également disponible pour C #. Par exemple, j'entends de grandes choses à propos de LINQ.

En résumé, représenter les requêtes sous forme de chaînes SQL empêche l'EDI de contribuer de manière significative à l'écriture et au refactoring des requêtes, retarde la détection de la syntaxe et des erreurs de type du moment de la compilation au moment de l'exécution, et contribue également aux vulnérabilités d'injection SQL [1]. Donc oui, il y a des raisons valables pour lesquelles on pourrait ne pas vouloir de chaînes SQL dans le code source.

[1]: Oui, l'utilisation correcte des instructions préparées empêche également l'injection SQL. Mais cette autre réponse de ce fil était vulnérable à une injection SQL jusqu'à ce qu'un commentateur ait souligné que cela n'inspire pas confiance aux programmeurs débutants qui les utilisent correctement à chaque fois que nécessaire ...

Beaucoup de bonnes réponses ici. Outre ce qui a déjà été dit, j'aimerais ajouter une autre chose.

Je ne considère pas l'utilisation de SQL en ligne comme un anti-modèle. Ce que je considère cependant comme un anti-modèle, c'est que chaque programmeur fait son propre travail. Vous devez décider en équipe d'une norme commune. Si tout le monde utilise linq, vous utilisez linq. Si tout le monde utilise des vues et des procédures stockées, vous le ferez.

Gardez toujours un esprit ouvert et ne tombez pas dans le dogme. Si votre magasin est un magasin "linq", vous l'utilisez. Sauf pour cet endroit où linq ne fonctionne absolument pas. (Mais vous ne devriez pas 99,9% du temps.)

Donc, ce que je ferais serait de rechercher le code dans la base de code et de vérifier comment vos collègues travaillent.

Le code ressemble à celui de la couche d'interaction de la base de données située entre la base de données et le reste du code. Si vraiment, ce n'est pas anti-modèle.

Cette méthode EST la partie de la couche, même si OP pense différemment (accès simple à la base de données, pas de mélange avec quoi que ce soit d'autre). C'est peut-être juste mal placé dans le code. Cette méthode appartient à la classe distincte "couche d'interface de base de données". Il serait contraire à la règle de le placer dans la classe ordinaire à côté des méthodes qui implémentent des activités autres que des bases de données.

L'anti-modèle serait d'appeler SQL à partir d'un autre endroit aléatoire du code. Vous devez définir une couche entre la base de données et le reste du code, mais ce n’est pas que vous deviez absolument utiliser un outil populaire qui pourrait vous aider.

À mon avis, non, ce n’est pas un modèle anti mais vous vous retrouverez face à un espacement de formatage de chaîne, en particulier pour les grandes requêtes qui ne peuvent pas tenir dans une seule ligne.

Un autre avantage est que cela devient beaucoup plus difficile lorsqu'il s'agit de requêtes dynamiques qui doivent être construites selon certaines conditions.

var query = "select * from accounts";

if(users.IsInRole('admin'))
{
   query += " join secret_balances";
}

Je suggère d'utiliser un constructeur de requête SQL

Pour de nombreuses entreprises modernes dotées de pipelines à déploiement rapide où les modifications de code peuvent être compilées, testées et mises en production en quelques minutes, il est tout à fait logique d'incorporer des instructions SQL dans le code de l'application. Ce n’est pas nécessairement un anti-modèle selon la façon dont vous vous y prenez.

De nos jours, l'utilisation des procédures stockées est un cas valable dans les organisations où de nombreux processus de déploiement de production peuvent impliquer des semaines de cycles d'assurance qualité, etc. Dans ce scénario, l'équipe DBA peut résoudre les problèmes de performances qui ne surviennent qu'après le déploiement de production initial en optimisant les requêtes dans les procédures stockées.

À moins que vous ne soyez dans cette situation, je vous recommande d'intégrer votre code SQL dans le code de votre application. Lisez les autres réponses dans ce fil pour obtenir des conseils sur la meilleure façon de s'y prendre.

Texte original ci-dessous pour contexte

Le principal avantage des procédures stockées est que vous pouvez optimiser les performances de la base de données sans recompiler ni redéployer votre application.

Dans de nombreuses organisations, le code ne peut être mis en production qu'après un cycle d'assurance qualité, etc., ce qui peut prendre des jours, voire des semaines. Si votre système rencontre un problème de performances de base de données en raison de modèles d'utilisation changeants ou d'une augmentation de la taille des tables, etc., il peut être assez difficile de localiser le problème avec des requêtes codées en dur, alors que la base de données aura des outils / rapports, etc., permettant d'identifier les procédures stockées posant problème. . Avec les procédures stockées, les solutions peuvent être testées / référencées en production et le problème peut être résolu rapidement sans avoir à pousser une nouvelle version du logiciel d'application.

Si ce problème n'est pas important pour votre système, il s'agit d'une décision parfaitement valide pour coder en dur des instructions SQL dans l'application.