Jakie są plusy i minusy utrzymywania SQL w przechowywanym Procs kontra Kod [zamknięty]

Jest to obecnie omawiane w kilku innych wątkach. Jestem konsekwentnym zwolennikiem procedur przechowywanych, chociaż przedstawiane są dobre argumenty przemawiające za LINQ do Sql.

Osadzanie zapytań w kodzie wiąże cię ściśle z modelem danych. Procedury składowane są dobrą formą programowania umownego, co oznacza, że DBA ma swobodę zmiany modelu danych i kodu w procedurze, o ile umowa reprezentowana przez Dane wejściowe procedury składowanej i dane wyjściowe są utrzymywane.

Strojenie baz danych produkcyjnych może być niezwykle trudne, gdy zapytania są zakopane w kodzie, a nie w jednej centralnej, łatwej do zarządzania lokalizacji.

[Edytuj] oto kolejna bieżąca Dyskusja

Moim zdaniem nie można głosować na tak lub nie w tej kwestii. To całkowicie zależy od projektu aplikacji.

CAŁKOWICIE głosuję przeciwko użyciu SPs w środowisku 3-warstwowym, gdzie masz serwer aplikacji z przodu. W tego rodzaju środowisku serwer aplikacji jest tam, aby uruchomić logikę biznesową. Jeśli dodatkowo używasz SPs zaczniesz dystrybuować implementację logiki biznesowej w całym systemie i stanie się bardzo niejasne, kto jest odpowiedzialny za co? W końcu skończysz z serwerem aplikacji, który w zasadzie nie zrobi nic poza:

(Pseudocode)

Function createOrder(Order yourOrder) 
Begin
  Call SP_createOrder(yourOrder)
End

Więc w końcu masz swój średni poziom uruchomiony na tym bardzo fajnym klastrze serwerów 4 każdy z nich wyposażony w procesory 16 i to naprawdę nic nie zrobi! Co za strata!

Jeśli masz klienta fat gui, który bezpośrednio łączy się z Twoim DB lub może nawet większą liczbą aplikacji, to już inna historia. W tej sytuacji SPs może służyć jako jakiś pseudo średni poziom to oddziela aplikację od modelu danych i oferuje kontrolowany dostęp.

Zalety w kodzie:

• łatwiejsze w utrzymaniu - nie trzeba uruchamiać skryptu SQL, aby aktualizować zapytania
• łatwiejsze portowanie do innego DB-no procs to port

• w końcu powtarzasz się w powiązanych blokach kodu
• SQL nie jest obsługiwany jako język w wielu IDE, więc masz tylko serię niezatwierdzonych błędów ciągów wykonujących zadania dla Ciebie
• zmiany typu danych, nazwy tabeli lub ograniczenia są znacznie bardziej powszechne niż Zamiana całej bazy danych na nową
• twój poziom trudności wzrasta wraz ze wzrostem złożoności zapytania
• i testowanie zapytania inline wymaga zbudowania projektu

Pomyśl o przechowywanych Procach jako o metodach wywoływanych z obiektu bazy danych - są one o wiele łatwiejsze do ponownego użycia, jest tylko jedno miejsce do edycji i w przypadku zmiany dostawców DB, zmiany zachodzą w przechowywanych Procach, a nie w kodzie.

To powiedziawszy, wzrost wydajności przechowywanych proc jest minimalny, jak powiedział Stu przede mną i nie możesz umieścić punktu przerwania w procedurze przechowywanej (jeszcze).

CON

Uważam, że wykonywanie wielu procesów wewnątrz procedur składowanych uczyniłoby Twój serwer DB jednym punktem nieelastyczności, jeśli chodzi o skalowanie twojego działania.

Jednak robienie tego wszystkiego w swoim programie w przeciwieństwie do serwera sql, może pozwolić ci na większe skalowanie, jeśli masz wiele serwerów, które obsługują Twój kod. Oczywiście nie dotyczy to przechowywanych procesorów, które wykonują tylko zwykłe pobieranie lub aktualizowanie, ale te, które wykonują więcej przetwarzania jak zapętlanie zbiorów danych.

Plusy

1. wydajność dla tego, co może być warte (unika parsowania zapytań przez sterownik DB / plan rekreacji itp.)
2. manipulacja danymi nie jest osadzona w kodzie C / C++ / C#, co oznacza, że mam mniej niskopoziomowy kod do przejrzenia. SQL jest mniej gadatliwy i łatwiejszy do przejrzenia, gdy jest wymieniony osobno.
3. ze względu na separację ludzie są w stanie znaleźć i ponownie użyć kodu SQL znacznie łatwiejsze.
4. Its easier to change things when zmiany w schemacie - wystarczy dać ten sam wynik do kodu i będzie działać dobrze
5. łatwiej przenieść do innej bazy danych.
6. mogę wyświetlić listę indywidualnych uprawnień dla moich procedur przechowywanych i kontrolować dostęp na tym poziomie.
7. mogę profilować moje zapytanie o dane / Kod trwałości oddzielnie od mojego kodu transformacji danych.
8. mogę wdrożyć zmienne warunki w mojej procedurze składowanej i łatwo byłoby je dostosować u klienta.
9. It łatwiej jest używać zautomatyzowanych narzędzi do konwertowania schematu i instrukcji razem, niż gdy jest on osadzony w moim kodzie, gdzie musiałbym je upolować.
10. zapewnienie najlepszych praktyk w zakresie dostępu do danych jest łatwiejsze, gdy masz cały kod dostępu do danych w jednym pliku - mogę sprawdzić, czy zapytania mają dostęp do tabeli nie wykonującej, lub do tabeli używającej wyższego poziomu serializacji lub select * ' s w kodzie itp.
11. łatwiej jest znaleźć zmiany w schemacie / logika manipulacji danymi zmienia się, gdy wszystkie są wymienione w jednym pliku.
12. łatwiej jest przeszukiwać i zastępować edycje w SQL, gdy są one w tym samym miejscu, np. Zmień / dodaj instrukcje izolacji transakcji dla wszystkich przechowywanych proc.
13. ja i facet DBA znaleźć, że posiadanie oddzielnego pliku SQL jest łatwiejsze / wygodne, gdy DBA musi przejrzeć moje rzeczy SQL.
14. na koniec nie musisz się martwić atakami SQL injection, ponieważ jakiś leniwy członek Twojego zespołu nie używał parametryzowane zapytania podczas korzystania z osadzonych SQL.

Przewaga wydajnościowa dla procedur składowanych jest często zaniedbywalna.

Więcej korzyści dla procedur składowanych:

• Zapobiegaj inżynierii odwrotnej (jeśli oczywiście utworzono z szyfrowaniem)
• lepsza centralizacja dostępu do bazy danych
• możliwość przezroczystej zmiany modelu danych (bez konieczności wdrażania nowych klientów); szczególnie przydatna, gdy wiele programów ma dostęp do tego samego modelu danych]}

I fall on the Kod bok. Tworzymy warstwę dostępu do danych, która jest używana przez wszystkie aplikacje (zarówno web, jak i klienckie), więc z tej perspektywy jest sucha. Upraszcza to wdrażanie bazy danych, ponieważ musimy tylko upewnić się, że schemat tabeli jest poprawny. Upraszcza to konserwację kodu, ponieważ nie musimy patrzeć na kod źródłowy i bazę danych.

Nie mam większego problemu z ciasnym połączeniem z modelem danych, ponieważ nie widzę, gdzie jest to możliwe naprawdę złamać to sprzęgło. Aplikacja i jej dane są ze sobą powiązane.

Procedury przechowywane.

Jeśli błąd się poślizgnie lub logika trochę się zmieni, nie musisz rekompilować projektu. Ponadto umożliwia dostęp z różnych źródeł, a nie tylko z jednego miejsca, w którym zakodowałeś zapytanie w swoim projekcie.

Nie sÄ ... dzÄ™, Ĺźe jest ciÄ ™ ĺźej utrzymywaÄ ‡ procedury przechowywane, nie naleĹźy ich kodowaÄ ‡ bezpoĹ " rednio w bazie danych, ale najpierw w osobnych plikach, potem moĹźna je uruchamiaÄ ‡ na dowolnym DB, ktĂłry trzeba skonfigurować.

Zalety procedur przechowywanych :

Łatwiej sprawdzić kod.

Mniej sprzężone, dlatego łatwiej przetestować.

Łatwiej dostroić.

Wydajność jest ogólnie lepsza, z punktu widzenia ruchu sieciowego - jeśli masz kursor, lub podobny, to nie ma wielu podróży do bazy danych

Możesz łatwiej chronić dostęp do danych, usuwać bezpośredni dostęp do tabel, egzekwować bezpieczeństwo poprzez procs - to również pozwala aby stosunkowo szybko znaleźć dowolny kod aktualizujący tabelę.

Jeśli w grę wchodzą inne usługi (takie jak usługi raportowania), może okazać się łatwiejsze przechowywanie całej logiki w procedurze składowanej, a nie w kodzie i powielanie jej

Wady:

Trudniejsze do zarządzania dla programistów: Kontrola wersji skryptów: czy każdy ma własną bazę danych, czy system kontroli wersji jest zintegrowany z bazą danych i IDE?

W pewnych okolicznościach dynamicznie tworzony sql w kodzie może mieć lepszą wydajność niż zapisany proc. Jeśli utworzyłeś zapisany proc (powiedzmy sp_customersearch), który staje się niezwykle skomplikowany z dziesiątkami parametrów, ponieważ musi być bardzo elastyczny, prawdopodobnie możesz wygenerować znacznie prostsze polecenie sql w kodzie podczas wykonywania.

Można by argumentować, że to po prostu przenosi pewne przetwarzanie z SQL do serwera www, ale ogólnie byłoby to dobre.

The inną wspaniałą rzeczą w tej technice jest to,że jeśli szukasz w SQL profiler, możesz zobaczyć wygenerowane zapytanie i debugować je znacznie łatwiej niż zobaczenie zapisanego wywołania proc Z 20 parametrami.

Lubię przechowywane proc, Nie wiem ile razy byłem w stanie dokonać zmiany w aplikacji przy użyciu procedury składowanej, która nie powodowała żadnych przestojów w aplikacji.

Wielki fan Transact SQL, strojenie dużych zapytań okazało się dla mnie bardzo przydatne. Nie pisałem żadnego inline SQL od około 6 lat!

Wymieniasz 2 pro-punkty za Zębatki:

Wydajność - niezupełnie. W Sql 2000 lub nowszym optymalizacja planu zapytań jest całkiem dobra i buforowana. Jestem pewien, że Wyrocznia itp robią podobne rzeczy. Nie wydaje mi się, aby sprocks miał więcej szans na osiągi.

Ochrona? Dlaczego sprocks miałby być bezpieczniejszy? Chyba, że masz dość niezabezpieczoną bazę danych i tak cały dostęp będzie z Twoich baz danych lub za pośrednictwem Twojej aplikacji. Zawsze parametryzuj wszystkie zapytania-nigdy w linii coś z wejścia użytkownika i będzie dobrze.

To i tak najlepsza praktyka w osiąganiu wyników.

Linq to zdecydowanie sposób na nowy projekt. Zobacz ten podobny post .

@Keith

Ochrona? Dlaczego sprocks miałby być bezpieczniejszy?

Zgodnie z sugestią Komradekatz, możesz zablokować dostęp do tabel (dla kombinacji nazwy użytkownika/hasła, która łączy się z DB) i zezwolić tylko na dostęp SP. W ten sposób, jeśli ktoś dostanie nazwę użytkownika i hasło do bazy danych, może wykonać SP, ale nie może uzyskać dostępu do tabel lub żadnej innej części DB.

(oczywiście wykonanie sprocks może dać im wszystkie potrzebne dane, ale to zależy od sprocks które były dostępne. Dając im dostęp do stołów daje im dostęp do wszystkiego.)

Pomyśl o tym w ten sposób

Masz 4 webservery i kilka aplikacji windows, które używają tego samego kodu SQL Teraz zdałeś sobie sprawę, że jest mały problem z kodem SQl ty też wolisz...... Zmień proc w 1 miejscu lub w tym celu zainstaluj ponownie wszystkie aplikacje na pulpicie(clickonce może pomóc) na wszystkich polach windows

Preferuję przechowywanie proc

Łatwiej jest również wykonać test wydajności na proc, umieścić go w analizatorze zapytań Ustaw statystyki io/czas on włącz showplan_text i voila

Nie trzeba uruchamiać profilera, aby zobaczyć dokładnie to, co się nazywa

Tylko moje 2 centy

Wolę trzymać w nich Kod (używając ORM, nie inline lub ad-hoc), więc są one objęte kontrolą źródła bez konieczności radzenia sobie z zapisywaniem.pliki sql.

Ponadto procedury składowane nie są z natury bardziej bezpieczne. Możesz napisać złe zapytanie za pomocą sproc tak samo łatwo jak inline. Parametryzowane zapytania inline mogą być tak samo bezpieczne jak sproc.

Użyj kodu aplikacji jako tego, co robi najlepiej: obsługa logiki.
Wykorzystaj swoją bazę danych do tego, co robi najlepiej: przechowuj dane.

Można debugować procedury przechowywane, ale łatwiej jest debugować i utrzymywać logikę w kodzie. Zazwyczaj kończysz rekompilację kodu za każdym razem, gdy zmienisz model bazy danych.

Również procedury składowane z opcjonalnymi parametrami wyszukiwania są bardzo niedoścignione, ponieważ trzeba wcześniej określić wszystkie możliwe parametry, a złożone wyszukiwania są czasami nie jest to możliwe, ponieważ nie można przewidzieć, ile razy parametr będzie powtarzany w seach.

Jeśli chodzi o bezpieczeństwo, procedury przechowywane są znacznie bezpieczniejsze. Niektórzy twierdzą, że cały dostęp będzie przez aplikację i tak. Wiele osób zapomina, że większość naruszeń bezpieczeństwa pochodzi z firmy. Pomyśl, ilu programistów zna "ukrytą" nazwę użytkownika i hasło do Twojej aplikacji?

Ponadto, jak zauważył MatthieuF, wydajność może zostać znacznie poprawiona dzięki mniejszej liczbie podróży między aplikacją (czy to na komputerze, czy serwer WWW) oraz serwer bazy danych.

Z mojego doświadczenia wynika, że abstrakcja modelu danych poprzez procedury przechowywane również znacznie poprawia konserwowalność. Jako ktoś, kto musiał utrzymywać wiele baz danych w przeszłości, jest to taka ulga w obliczu wymaganej zmiany modelu, aby móc po prostu zmienić procedurę składowaną lub dwie i aby zmiana była całkowicie przejrzysta dla wszystkich zewnętrznych aplikacji. Wielokrotnie Twoja aplikacja nie jest jedyną wskazaną w bazie danych-tam są inne aplikacje, rozwiązania raportowania itp. tak więc śledzenie wszystkich dotkniętych punktów może być kłopotliwe z otwartym dostępem do stołów.

Umieszczę również w kolumnie Plus sprawdzanie, czy programowanie SQL jest w rękach tych, którzy się w nim specjalizują, a SPs znacznie ułatwia izolowanie i testowanie/optymalizację kodu.

Jedynym minusem, który widzę jest to, że wiele języków nie pozwala na przekazywanie parametrów tabeli, więc przekazywanie nieznanych wartości danych liczbowych może być irytujące, a niektóre języki nadal nie mogą poradzić sobie z pobieraniem wielu wyników z jednej procedury składowanej (chociaż ta ostatnia nie czyni SPs gorszym niż inline SQL pod tym względem).

Jedna z sugestii z sesji Microsoft TechEd na temat bezpieczeństwa, w której uczestniczyłem, aby wszystkie połączenia przez przechowywane procs i odmówić dostępu bezpośrednio do tabel. Takie podejście było rozliczane jako zapewniające dodatkowe bezpieczeństwo. Nie jestem pewien, czy warto to tylko dla bezpieczeństwa, ale jeśli już używasz przechowywanych proc, nie zaszkodzi.

Zdecydowanie łatwiejsze w utrzymaniu, jeśli umieścisz go w procedurze składowanej. Jeśli w grę wchodzi trudna logika, która potencjalnie zmieni się w przyszłości, zdecydowanie dobrym pomysłem jest umieszczenie jej w bazie danych, gdy łączy się z nią wielu klientów. Na przykład pracuję teraz nad aplikacją, która ma interfejs użytkownika końcowego i administracyjną aplikację desktopową, z których obie dzielą bazę danych (oczywiście) i staram się zachować jak najwięcej logiki w bazie danych, jak to możliwe. To jest doskonałym przykładem Zasady suchej.

Jestem zdecydowanie po stronie przechowywanych procków, zakładając, że nie oszukujesz i nie używasz dynamicznego SQL w przechowywanym procku. Po pierwsze, użycie przechowywanych proc pozwala dba ustawić uprawnienia na poziomie przechowywanych proc, a nie na poziomie tabeli. Ma to krytyczne znaczenie nie tylko w zwalczaniu attactów SQL injection, ale także w zapobieganiu bezpośrednim dostępowi do bazy danych i zmienianiu rzeczy. Jest to sposób na zapobieganie oszustwom. Brak bazy danych zawierającej dane osobowe (SSN, numery kart kredytowych itp.) lub w anyway tworzy transakcje finansowe powinny być kiedykolwiek dostępne z wyjątkiem procedur strored. Jeśli używasz innej metody, zostawiasz swoją bazę danych otwartą dla osób w firmie, aby tworzyć fałszywe transakcje finansowe lub kraść dane, które mogą być wykorzystane do kradzieży tożsamości.

Przechowywane proc są również o wiele łatwiejsze w utrzymaniu i dostrajaniu wydajności niż SQL wysyłany z aplikacji. Pozwalają również dba sposób, aby zobaczyć, jaki wpływ zmiany strukturalnej bazy danych będzie miał na drodze dostęp do danych. Nigdy nie spotkałem dobrego dba, który umożliwiłby dynamiczny dostęp do bazy danych.

Używamy procedur składowanych z Oracle DB tam, gdzie teraz pracuję. Używamy również Subversion. Wszystkie procedury przechowywane są tworzone jako .pkb & .pliki pks i zapisane w Subversion. Zrobiłem wcześniej in-line SQL i to jest ból! Wolę sposób, w jaki to robimy tutaj. Tworzenie i testowanie nowych procedur składowanych jest o wiele łatwiejsze niż robienie tego w kodzie.

Theresa

Mniejsze kłody

Kolejny drobny pro dla procedur składowanych, o których nie wspomniano: jeśli chodzi o ruch SQL, dostęp do danych oparty na Sp generuje znacznie mniejszy ruch. Staje się to ważne, gdy monitorujesz ruch w celu analizy i profilowania - dzienniki będą znacznie mniejsze i czytelne.

Nie jestem wielkim fanem procedur przechowywanych, ale używam ich pod jednym warunkiem:

Gdy zapytanie jest dość duże, lepiej przechowywać je w bazie danych jako procedurę składowaną, zamiast wysyłać je z kodu. W ten sposób, zamiast wysyłać ogromne ilości znaków łańcuchowych z serwera aplikacji do bazy danych, zostanie wysłane tylko polecenie "EXEC SPNAME".

Jest to przesada, gdy serwer bazy danych i serwer WWW nie są w tej samej sieci (na przykład internet komunikacji). A nawet jeśli tak nie jest, zbyt duży stres oznacza dużo zmarnowanego pasma.

Przechowywany proc SQL nie zwiększa wydajności zapytania

Oczywiście używanie procedur składowanych ma kilka zalet w stosunku do konstruowania SQL w kodzie.

1. implementacja kodu i SQL stają się niezależne od siebie.
2. kod jest łatwiejszy do odczytania.
3. Pisz raz użyć wiele razy.
4. Modyfikuj raz
5. nie ma potrzeby podawania programistom wewnętrznych informacji o bazie danych. itd, itp.

Procedury przechowywane są Bardziej utrzymywalne, ponieważ:

• nie musisz rekompilować aplikacji C#, gdy chcesz zmienić jakiś SQL
• Kończy się ponownym użyciem kodu SQL.

Powtarzanie kodu jest najgorszą rzeczą, jaką możesz zrobić, gdy próbujesz zbudować łatwą do utrzymania aplikację!

Co się stanie, gdy znajdziesz błąd logiczny, który trzeba poprawić w wielu miejscach? Jesteś bardziej skłonny zapomnieć o zmianie ostatniego miejsca, w którym kopiujesz & wklejony kod.

Moim zdaniem korzyści z wydajności i bezpieczeństwa są dodatkowym plusem. nadal możesz pisać niebezpieczne / nieefektywne procedury przechowywane SQL.

Łatwiejsze portowanie do innego DB - no procs to port

Nie jest trudno skryptować wszystkie procedury przechowywane do tworzenia w innym DB. W rzeczywistości-jest to łatwiejsze niż eksportowanie tabel, ponieważ nie ma podstawowych/obcych kluczy, którymi trzeba się martwić.

@ Terrapin-sprocks są tak samo podatne na ataki iniekcji. Jak powiedziałem:

Zawsze parametryzuj wszystkie zapytania-nigdy nie wpisuj czegoś z danych wejściowych użytkownika i będzie dobrze.

To dotyczy sprocks i dynamic Sql.

Nie jestem pewien, czy nie przekompilowanie aplikacji jest zaletą. Chodzi mi o to, że przeprowadziłeś testy jednostkowe na podstawie tego kodu (zarówno aplikacji, jak i DB) przed ponownym uruchomieniem.

@ Guy-tak masz rację, sprocks pozwalają Ci kontrolować użytkownicy aplikacji tak, że mogą wykonywać tylko sproc, a nie podstawową akcję.

Moje pytanie brzmiałoby: jeśli wszystkie dostęp do niego za pośrednictwem aplikacji, za pomocą połączeń i użytkowników z ograniczonymi prawami do aktualizacji / wstawiania itp, Czy ten dodatkowy poziom dodaje bezpieczeństwo lub dodatkową administrację?

Moim zdaniem jest to drugie. Jeśli skompromitowali Twoją aplikację do momentu, w którym mogą ją ponownie napisać, mają wiele innych ataków, których mogą użyć.

SQL Injection can nadal być wykonywane w stosunku do tych zębatek, jeśli dynamicznie kod inline, więc złota reguła nadal obowiązuje, wszystkie dane wejściowe użytkownika muszą być zawsze parametryzowane.

Coś, czego do tej pory nie widziałem: ludzie, którzy znają bazę danych najlepiej, nie zawsze są ludźmi, którzy piszą kod aplikacji. Procedury przechowywane dają ludziom z bazy danych sposób na interfejs z programistami, którzy tak naprawdę nie chcą dowiedzieć się zbyt wiele o SQL. Duże-a zwłaszcza starsze-bazy danych nie są najłatwiejszymi rzeczami do pełnego zrozumienia, więc programiści mogą preferować prosty interfejs, który daje im to, czego potrzebują: pozwól DBAs dowiedzieć się, jak dołączyć 17 stołów, aby tak się stało.

To powiedziawszy, języki używane do pisania procedur składowanych (PL / SQL jest notorycznym przykładem) są dość brutalne. Zazwyczaj nie oferują żadnej z miłych rzeczy, które można zobaczyć w dzisiejszych popularnych językach imperatywnych, OOP lub funkcyjnych. Pomyśl o COBOLu.

Tak więc, trzymaj się procedur składowanych, które po prostu abstrakują szczegóły relacyjne, a nie te, które zawierają logikę biznesową.

Generalnie piszę kod OO. Podejrzewam, że większość z Was pewnie też. W tym kontekście wydaje mi się oczywiste, że cała logika biznesowa-w tym zapytania SQL-należy do definicji klas. Rozdzielenie logiki tak, aby część znajdowała się w modelu obiektowym, a część w bazie danych nie było lepsze niż wprowadzenie logiki biznesowej do interfejsu użytkownika.

Wiele zostało powiedziane we wcześniejszych odpowiedziach na temat korzyści bezpieczeństwa przechowywanych proc. Dzielą się one na dwie szerokie kategorie:

1) ograniczenie bezpośredniego dostępu do danych. Jest to z pewnością ważne w niektórych przypadkach, a gdy go napotkasz, przechowywane proc są w zasadzie jedyną opcją. Z mojego doświadczenia wynika jednak, że takie przypadki są raczej wyjątkiem niż regułą.

2) zapytania SQL injection/parametryzowane. Ten sprzeciw to czerwony śledź. Inline SQL - nawet dynamicznie generowany inline SQL-może być tak samo sparametryzowany jak każdy zapisany proc i może być wykonany tak samo łatwo w każdym nowoczesnym języku wartym swojej soli. Nie ma żadnej przewagi. ("Leniwi programiści mogą nie przejmować się używaniem parametrów" nie jest prawidłowym sprzeciwem. Jeśli masz programistów w swoim zespole, którzy wolą po prostu połączyć dane użytkownika z ich SQL zamiast używać parametrów, najpierw próbujesz ich edukować, a następnie zwalniasz ich, jeśli to nie zadziała, tak jak w przypadku programistów, którzy mają inny zły, wyraźnie szkodliwy nawyk.)

Jestem wielkim zwolennikiem kodu nad SPROC ' s. powodem numer jeden jest utrzymywanie kodu ściśle powiązane, następnie Bliski drugi jest łatwość kontroli źródła bez wielu niestandardowych narzędzi do wciągnięcia go w.

W naszym DAL jeśli mamy bardzo złożone instrukcje SQL, zazwyczaj dołączamy je jako pliki zasobów i aktualizujemy je w razie potrzeby(może to być również oddzielny zespół, i zamieniane na db, itp...).

Dzięki temu nasz kod i nasze wywołania sql są przechowywane w tej samej wersji kontroluj, nie "zapominając", aby uruchomić niektóre zewnętrzne aplikacje do aktualizacji.