What are the advantages/disadvantages of keeping SQL in your C# source code or in Stored Procs? I've been discussing this with a friend on an open source project that we're working on (C# ASP.NET Forum). At the moment, most of the database access is done by building the SQL inline in C# and calling to the SQL Server DB. So I'm trying to establish which, for this particular project, would be best.

So far I have:

Advantages for in Code:

  • Easier to maintain - don't need to run a SQL script to update queries
  • Easier to port to another DB - no procs to port

Advantages for Stored Procs:

  • Performance
  • Security
+15  A: 

The performance advantage for stored procedures is often negligable.

More advantages for stored procedures:

  • Prevent reverse engineering (if created With Encryption, of course)
  • Better centralization of database access
  • Ability to change data model transparently (without having to deploy new clients); especially handy if multiple programs access the same data model
+9  A: 

Stored procedures.

If an error slips or the logic changes a bit, you do not have to recompile the project. Plus, it allows access from different sources, not just the one place you coded the query in your project.

I don't think it is harder to maintain stored procedures, you should not code them directly in the database but in separate files first, then you can just run them on whatever DB you need to set-up.

If you find yourself making basic architectural decisions to avoid recompiling your code, then before doing anything at all, establish build process that doesn't totally suck. This is a non-argument.
Michael Borgwardt
+5  A: 

I prefer keeping in them in code (using an ORM, not inline or ad-hoc) so they're covered by source control without having to deal with saving out .sql files.

Also, stored procedures aren't inherently more secure. You can write a bad query with a sproc just as easily as inline. Parameterized inline queries can be just as secure as a sproc.

John Sheehan
+56  A: 

This is being discussed on a few other threads here currently. I'm a consistent proponent of stored procedures, although some good arguments for Linq to Sql are being presented.

Embedding queries in your code couples you tightly to your data model. Stored procedures are a good form of contractual programming, meaning that a DBA has the freedom to alter the data model and the code in the procedure, so long as the contract represented by the stored procedure's inputs and outputs is maintained.

Tuning production databases can be extremely difficult when the queries are buried in the code and not in one central, easy to manage location.

[Edit] Here is another current discussion

Eric Z Beard
"Embedding queries in your code couples you tightly to your data model" - Show me an app that isn't coupled to it's data model.
Neil Barnwell
"Stored procedures are a good form of contractual programming, meaning that a DBA has the freedom to alter the data model and the code in the procedure" - How is this a good thing? Do the DBAs in your company fully understand the customer requirements and impact of changes?
Neil Barnwell
If you do your design right, the only region of your code that should be impacted by a data change is the persistence layer. If you use stored procedure and the inputs/outputs stays the same... the code can still work even if the DBA denormalize the schema of the database for performance reason. Stored procedure is another way of separating concerns. The persistence layer is supposed to care about the data, not the schema. If you build a contract (read: stored procedure) between the persistence layer and the DB, you can change the DB without impacting the persistence layer too much.
+26  A: 

Advantages for in Code:

  • Easier to maintain - don't need to run a SQL script to update queries
  • Easier to port to another DB - no procs to port

Actually, I think you have that backwards. IMHO, SQL in code is pain to maintain because:

  • you end up repeating yourself in related code blocks
  • SQL isn't supported as a language in many IDE's so you have just a series of un-error checked strings performing tasks for you
  • changes in a data type, table name or constraint are far more prevalent than swapping out an entire databases for a new one
  • your level of difficulty increases as your query grows in complexity
  • and testing an inline query requires building the project

Think of Stored Procs as methods you call from the database object - they are much easier to reuse, there is only one place to edit and in the event that you do change DB providers, the changes happen in your Stored Procs and not in your code.

That said, the performance gains of stored procs is minimal as Stu said before me and you can't put a break point in a stored procedure (yet).

Rob Allen
+1, especially the part about the un-error checked strings
John M Gant
+1, also for testing an inline query. Of course you can break complex SQL into simpler blocks, but then these blocks will no longer be testable directly (because they are not valid SQL in isolation), unlike sprocs.
+1 because you mention almost every problem we encounter in our projects. We are actually slowly shifting into using *more* stored procedures io less. This goes especially for reporting. With stored procedures returning all the data required for the report, it's a snap to save a baseline of the data, make a change to the sp and compare the differences with the baseline to verify the change.
But if you use an ORM tool, then you don't have SQL strings in your code at all, but a more type safe way of generating your SQL.
@paddy - you are correct that you do not have sql strings - instead you have an additional layer of abstraction which may or may not offer the performance/coding speed balance your project needs. Its something to consider, but put all the cards on the table.
Rob Allen
+3  A: 

One of the suggestions from a Microsoft TechEd sessions on security which I attended, to make all calls through stored procs and deny access directly to the tables. This approach was billed as providing additional security. I'm not sure if it's worth it just for security, but if you're already using stored procs, it couldn't hurt.

Eugene Katz
Data security is important when you are deling with personal information or finanical imformation especially. Most fraud is committed by insiders. You don't want to give them the access they need to bypass internal controls.
+4  A: 

Definitely easier to maintain if you put it in a stored procedure. If there's difficult logic involved that will potentially change in the future it is definitely a good idea to put it in the database when you have multiple clients connecting. For example I'm working on an application right now that has an end user web interface and an administrative desktop application, both of which share a database (obviously) and I'm trying to keep as much logic on the database as possible. This is a perfect example of the DRY principle.

Andrew G. Johnson
+5  A: 

Think of it this way

You have 4 webservers and a bunch of windows apps which use the same SQL code Now you realized there is a small problem with the SQl code so do you rather...... change the proc in 1 place or push the code to all the webservers, reinstall all the desktop apps(clickonce might help) on all the windows boxes

I prefer stored procs

It is also easier to do performance testing against a proc, put it in query analyzer set statistics io/time on set showplan_text on and voila

no need to run profiler to see exactly what is being called

just my 2 cents

+6  A: 

You list 2 pro-points for sprocs:

Performance - not really. In Sql 2000 or greater the query plan optimisations are pretty good, and cached. I'm sure that Oracle etc do similar things. I don't think there's a case for sprocs for performance any more.

Security? Why would sprocs be more secure? Unless you have a pretty unsecured database anyway all the access is going to be from your DBAs or via your application. Always parametrise all queries - never inline something from user input and you'll be fine.

That's best practice for performance anyway.

Linq is definitely the way I'd go on a new project right now. See this similar post.

Ad-hoc SQL execution plans are only reused in specific circumstances: [SO answer with code proof]LINQ to SQL is officially dead: [blog post]
+11  A: 

I fall on the code side. We build data access layer that's used by all all the apps (both web and client), so it's DRY from that perspective. It simplifies the database deployment because we just have to make sure the table schema's are correct. It simplifies code maintenance because we don't have to look at source code and the database.

I don't have much problem with the tight coupling with the data model because I don't see where it's possible to really break that coupling. An application and its data are inherently coupled.

+8  A: 

Advantages for Stored procedures:

More easily code reviewed.

Less coupled, therefore more easily tested.

More easily tuned.

Performance is generally better, from the point of view of network traffic - if you have a cursor, or similar, then there aren't multiple trips to the database

You can protect access to the data more easily, remove direct access to the tables, enforce security through the procs - this also allows you to find relatively quickly any code that updates a table.

If there are other services involved (such as Reporting services), you may find it easier to store all of your logic in a stored procedure, rather than in code, and having to duplicate it


Harder to manage for the developers: version control of the scripts: does everyone have their own database, is the version control system integrated with the database and IDE?

+1  A: 

Stored Procedures are MORE maintainable because:

  • You don't have to recompile your C# app whenever you want to change some SQL
  • You end up reusing SQL code.

Code repetition is the worst thing you can do when you're trying to build a maintainable application!

What happens when you find a logic error that needs to be corrected in multiple places? You're more apt to forget to change that last spot where you copy & pasted your code.

In my opinion, the performance & security gains are an added plus. You can still write insecure/inefficient SQL stored procedures.

Easier to port to another DB - no procs to port

It's not very hard to script out all your stored procedures for creation in another DB. In fact - it's easier than exporting your tables because there are no primary/foreign keys to worry about.

Just a note: "Easier to port to another DB - no procs to port" referred to porting to *another DBMS*, not just another installation. There are alternatives out there, you know ;-).
+1  A: 


Security? Why would sprocs be more secure?

Stored procedures offer inherent protection from SQL Injection attacks.

However, you're not completely protected because you can still write stored procedures that are vulnerable to such attacks (i.e. dynamic SQL in a stored proc).

+7  A: 


Security? Why would sprocs be more secure?

As suggested by Komradekatz, you can disallow access to tables (for the username/password combo that connects to the DB) and allow SP access only. That way if someone gets the username and password to your database they can execute SP's but can't access the tables or any other part of the DB.

(Of course executing sprocs may give them all the data they need but that would depend on the sprocs that were available. Giving them access to the tables gives them access to everything.)

Joe Philllips
+2  A: 

@Terrapin - sprocs are just as vulnerable to injection attacks. As I said:

Always parametrise all queries - never inline something from user input and you'll be fine.

That goes for sprocs and dynamic Sql.

I'm not sure not recompiling your app is an advantage. I mean, you have run your unit tests against that code (both application and DB) before going live again anyway.

@Guy - yes you're right, sprocs do let you control application users so that they can only perform the sproc, not the underlying action.

My question would be: if all the access it through your app, using connections and users with limited rights to update/insert etc, does this extra level add security or extra administration?

My opinion is very much the latter. If they've compromised your application to the point where they can re-write it they have plenty of other attacks they can use.

Sql injections can still be performed against those sprocs if they dynamically inline code, so the golden rule still applies, all user input must always be parametrised.

It isn't just outside atacks you need to fight. You cannot allow direct access to the tables to users who could then alter the data to commit fraud.
AS a policy, stored procs should not be allowed to use dynamic sql, there is almost always a non-dynamic solution if you look for it.
SQL injection is not so effective against sprocs with dynamically-inlined code because dynamic code executes with caller permission, not owner permission (unlike static code). This is true for SQL Server - not sure about Oracle.
+70  A: 

I am not a fan of stored procedures

Stored Procedures are MORE maintainable because: * You don't have to recompile your C# app whenever you want to change some SQL

You'll end up recompiling it anyway when datatypes change, or you want to return an extra column, or whatever. The number of times you can 'transparently' change the SQL out from underneath your app is pretty small on the whole

  • You end up reusing SQL code.

Programming languages, C# included, have this amazing thing, called a function. It means you can invoke the same block of code from multiple places! Amazing! You can then put the re-usable SQL code inside one of these, or if you want to get really high tech, you can use a library which does it for you. I believe they're called Object Relational Mappers, and are pretty common these days.

Code repetition is the worst thing you can do when you're trying to build a maintainable application!

Agreed, which is why storedprocs are a bad thing. It's much easier to refactor and decompose (break into smaller parts) code into functions than SQL into... blocks of SQL?

You have 4 webservers and a bunch of windows apps which use the same SQL code Now you realized there is a small problem with the SQl code so do you rather...... change the proc in 1 place or push the code to all the webservers, reinstall all the desktop apps(clickonce might help) on all the windows boxes

Why are your windows apps connecting directly to a central database? That seems like a HUGE security hole right there, and bottleneck as it rules out server-side caching. Shouldn't they be connecting via a web service or similar to your web servers?

So, push 1 new sproc, or 4 new webservers?

Inn this case it is easier to push one new sproc, but in my experience, 95% of 'pushed changes' affect the code and not the database. If you're pushing 20 things to the webservers that month, and 1 to the database, you hardly lose much if you instead push 21 things to the webservers, and zero to the database.

More easily code reviewed.

Can you explain how? I don't get this. Particularly seeing as the sprocs probably aren't in source control, and therefore can't be accessed via web-based SCM browsers and so on.

More cons:

Storedprocs live in the database, which appears to the outside world as a black box. Simple things like wanting to put them in source control becomes a nightmare.

There's also the issue of sheer effort. It might make sense to break everything down into a million tiers if you're trying to justify to your CEO why it just cost them 7 million dollars to build some forums, but otherwise creating a storedproc for every little thing is just extra donkeywork for no benefit.

Orion Edwards
Your very first statement is somewhat flawed. you can change the guts of the stored proc without changing the signature and that is VERY helpful and without re-compiling your c#.
Your comment about breaking into block of SQL is flawed too - ever heard of TSQL or PL/SQL - these are procedural language within SQLServer and Oracle - stored procs are made up of them and embedded sql. You can work with them just like you can with C# methods. Not much difference.
I think that Orion's point regarding breaking up logic was at least partially referring to the great refactoring tools available for object-oriented languages (such as those found in Visual Studio) that make splitting things up considerably easier than creating a sub-procedure in TSQL
Brian Sullivan
The business about functions only applies if you have only .NET applications accessing the data. If you have a mixture of .NET, Java, and others, all can share the stored procedures.
re code review, sqldepends is a nice tool which doesn' exist afaik if you use code instead of stored procs.
"Particularly seeing as the sprocs probably aren't in source control". Why would sprocs not be in source control? Any respectable shop would...
Not many shops are "respectable" :-)Anyway, the point is that it is more difficult to keep sprocs in source control, because you always have 2 copies (the one in the DB, and the one in the file) which can and do go out of sync. This can be worked around with strict process, but it's not simple
Orion Edwards
Just have everyone modify the source controlled .sql script, just like any .cs file. If you are using SVN for example, you can have a hook that executes the script as it gets commited. Great for handling merges too, since people tend to forget to execute the merged SQL script.
@Kevin.. in the real world that doesn't really work. Especially when we have deadlines. My shop currently runs using sprocs and I'd love it if we didn't. Every 2 days I hear someone cussing that someone changed the sproc in a hurry to add a feature and didn't tell anyone or test it fully. It comes down to process and most places don't have a good enough process to accoutn for sprocs.
Joe Philllips
re sproc being used by a mixture of .NET, java, etc... If you have multiple components, let alone platforms calling the same sproc, seems like a smell to me.
Jiho Han
Although you probably won't have really complex code in a sproc you can easily unit test it with something like tsqlunit. This allows you to hire SQL focused devs rather than, say, C# devs with average SQL skills.
Chris Oldwood
@Chris Oldwood: Hiring "sql focused devs" seems like a nice idea if you have 300 developers and want to specialize like that, but personally I've never seen an application where the SQL was more than maybe 5% of the total code. To me that makes as much sense as hiring "Batch file focused devs" or "Registry focused devs"...
Orion Edwards
P.S. There is a great tool we use here for SQL Source Control. I'm a big fan.
+4  A: 

Use your app code as what it does best: handle logic.
User your database for what it does best: store data.

You can debug stored procedures but you will find easier to debug and maintaing logic in code. Usually you will end recompiling your code every time you change the database model.

Also stored procedures with optional search parameters are very inneficient because you have to specify in advance all the possible parameters and complex searches are sometimes not possible because you cant predict how many times a parameter is going to be repeated in the seach.

When multiple apps hit the same database, and databases are affected by imports and other direct access (update all the prices by 10%), the logic must be in the database or you will lose database integrity.
For the case of multiple apps, placing the logic into a library which is used by all apps allows integrity to be maintained while still keeping the logic in the app language. For imports/direct access, it's generally situational as to whether the rules which apply to apps should be enforced or not.
Dave Sherohman
multiple apps shouldn't be making the same type of changes to the database. there should be one app component that deals with a single type of changes. Then that app should expose a service if others are interested. Multiple apps changing the same database/table in whatever way they see fit is what causes a system of apps and the database to become unmaintainable.
Jiho Han
" there should be one app component that deals with a single type of changes" -- That component could be a stored procedure, say in PL/SQL.
+1  A: 

SQL injection attacks are on the upswing. It's very easy for someone to find this code and run injection attacks on your website. You must always always parameterize your queries. It's best to never run exec(@x) on a dynamic SQL query. It's just not a great idea to use inline SQL ever, IMO.

Stored Procedures, as argued by some, are a hassle because they are another set of items to maintain separate from your code. But they are reusable and if you end up finding a bug in your queries, you can at fix them without recompiling.

Non-sequitur. Inline and dynamic queries can be parametrized just as easily as stored procs.
Dave Sherohman

I'd like to cast another vote for using stored procs (despite the hassle they can introduce when it comes to maintenance and versioning) as a way to restrict direct access to the underlying tables for better security.

To cast your vote you just use the triangle arrow to the left of the answer you liked ;)
+5  A: 

I like stored procs, dont know how many times I was able to make a change to an application using a stored procedure which didn't produce any downtime to the application.

Big fan of Transact SQL, tuning large queries have proven to be very useful for me. Haven't wrote any inline SQL in about 6 years!

+7  A: 

In some circumstances, dynamically created sql in code can have better performance than a stored proc. If you have created a stored proc (let's say sp_customersearch) that gets extremely complicated with dozens of parameters because it must be very flexible, you can probably generate a much simpler sql statement in code at runtime.

One could argue that this simply moves some processing from SQL to the web server, but in general that would be a good thing.

The other great thing about this technique is that if you're looking in SQL profiler you can see the query you generated and debug it much easier than seeing a stored proc call with 20 parameters come in.

Not sure why this answer was voted down.. it's true that a smaller query can perform better. This has even been commented on by the SQL Server team.
+1  A: 

Something that I haven't seen mentioned thus far: the people who know the database best aren't always the people that write the application code. Stored procedures give the database folks a way to interface with programmers that don't really want to learn that much about SQL. Large--and especially legacy--databases aren't the easiest things to completely understand, so programmers might just prefer a simple interface that gives them what they need: let the DBAs figure out how to join the 17 tables to make that happen.

That being said, the languages used to write stored procedures (PL/SQL being a notorious example) are pretty brutal. They typically don't offer any of the niceties you'd see in today's popular imperative, OOP, or functional languages. Think COBOL.

So, stick to stored procedures that merely abstract away the relational details rather than those that contain business logic.

"The languages used to write stored procedures (PL/SQL being a notorious example) are pretty brutal [and] don't offer any of the niceties you'd see in today's popular languages." You need to re-read the PL/SQL docs ( PL/SQL has encapsulation using packages, OOP via object types, exception handling, dynamic execution of code, debuggers, profilers, etc., plus hundreds of standard, Oracle-supplied packages/libraries for doing everything from HTTP calls to encryption and regular expressions. PL/SQL has LOTS of niceties.
+3  A: 

When it comes to security, stored procedures are much more secure. Some have argued that all access will be through the application anyway. The thing that many people are forgetting is that most security breaches come from inside a company. Think about how many developers know the "hidden" user name and password for your application?

Also, as MatthieuF pointed out, performance can be much improved due to fewer round trips between the application (whether it's on a desktop or web server) and the database server.

In my experience the abstraction of the data model through stored procedures also vastly improves maintainability. As someone who has had to maintain many databases in the past, it's such a relief when confronted with a required model change to be able to simply change a stored procedure or two and have the change be completely transparent to ALL outside applications. Many times your application isn't the only one pointed at a database - there are other applications, reporting solutions, etc. so tracking down all of those affected points can be a hassle with open access to the tables.

I'll also put checks in the plus column for putting the SQL programming in the hands of those who specialize in it, and for SPs making it much easier to isolate and test/optimize code.

The one downside that I see is that many languages don't allow the passing of table parameters, so passing an unknown number data values can be annoying, and some languages still can't handle retrieving multiple resultsets from a single stored procedure (although the latter doesn't make SPs any worse than inline SQL in that respect).

Tom H.
When the model changes, usually the code needs to change as well regardless of whether one is using sprocs or dynamic sql. And once you create tables/schema how often do you change just the table/schema? Not often. Usually changes come from business where they need to add another column or another table, in which case, I doubt you can do without a code change.
Jiho Han
+13  A: 


I find that doing lots of processing inside stored procedures would make your DB server a single point of inflexibility, when it comes to scaling your act.

However doing all that crunching in your program as opposed to the sql-server, might allow you to scale more if you have multiple servers that runs your code. Of-course this does not apply to stored procs that only does the normal fetch or update but to ones that perform more processing like looping over datasets.


  1. Performance for what it may be worth (avoids query parsing by DB driver / plan recreation etc)
  2. Data manipulation is not embedded in the C/C++/C# code which means I have less low level code to look through. SQL is less verbose and easier to look through when listed separately.
  3. Due to the separation folks are able to find and reuse SQL code much easier.
  4. Its easier to change things when schema changes - you just have to give the same output to the code and it will work just fine
  5. Easier to port to a different database.
  6. I can list individual permissions on my stored procedures and control access at that level too.
  7. I can profile my data query/ persistence code separate from my data transformation code.
  8. I can implement changeable conditions in my stored procedure and it would be easy to customize at a customer site.
  9. It becomes easier to use some automated tools to convert my schema and statements together rather than when it is embedded inside my code where I would have to hunt them down.
  10. Ensuring best practices for data access is easier when you have all your data access code inside a single file - I can check for queries that access the non performant table or that which uses a higher level of serialization or select *'s in the code etc.
  11. It becomes easier to find schema changes / data manipulation logic changes when all of it is listed in one file.
  12. It becomes easier to do search and replace edits on SQL when they are in the same place e.g. change / add transaction isolation statements for all stored procs.
  13. I and the DBA guy find that having a separate SQL file is easier / convenient when the DBA has to review my SQL stuff.
  14. Lastly you don't have to worry about SQL injection attacks because some lazy member of your team did not use parametrized queries when using embedded sqls.
This is the first time I see someone list "Easier to port to a different database" as an *advantage* of sprocs. It's usually the reverse. But with sprocs in Java or another cross-platform language, it might actually be true.

I have yet to find a good way of easily maintaining stored procs in source control that makes it as seamless as the code base. It just doesn't happen. This alone makes putting the SQL in your code worthwhile for me. Performance differences are negligible on modern systems.

What's so difficult about pressing "Generate Script" button and committing it to repository?
We have no problem keeping all stored procs in source control. Of course our dbas delete any that aren't in it.
+1  A: 

Stored procedures are the worst when they are used to stand in-between applications and the database. Many of the reasons for their use stated above are better handled by views.

The security argument is spurious. It just moves the security problem from the application to the database. Code is code. I have seen stored procedures that take in SQL from the applications and use it build queries that were subject to SQL injection attacks.

In general, they tend to create a rift between so-called database developers and so-called application developers. In reality, all of the code that is written is application code, it is only a difference of the execution context.

Using rich SQL generation libraries like LINQ, Rails ActiveRecord, or Hibernate/NHibernate makes development faster. Inserting stored procedures in the mix slows it down.

I have to strongly disagree with this statement. All code is not application code, stored procs are more secure if you do not allow dynamic sql (which you should not) because then you can set security at the sp level and not the table level. This is prevent fraud.
+2  A: 

Smaller logs

Another minor pro for stored procedures that has not been mentioned: when it comes to SQL traffic, sp-based data access generates much less traffic. This becomes important when you monitor traffic for analysis and profiling - the logs will be much smaller and readable.

+2  A: 

I'm firmly on the side of stored procs assuming you don't cheat and use dynamic SQL in the stored proc. First, using stored procs allows the dba to set permissions at the stored proc level and not the table level. This is critical not only to combating SQL injection attacts but towards preventing insiders from directly accessing the database and changing things. This is a way to help prevent fraud. No database that contains personal information (SSNs, Credit card numbers, etc) or that in anyway creates financial transactions should ever be accessed except through strored procedures. If you use any other method you are leaving your database wide open for individuals in the company to create fake financial transactions or steal data that can be used for identity theft.

Stored procs are also far easier to maintain and performance tune than SQL sent from the app. They also allow the dba a way to see what the impact of a database structural change will have on the way the data is accessed. I've never met a good dba who would allow dynamic access to the database.

+1  A: 

I prefer to use an O/R Mapper such as LLBLGen Pro.

It gives you relatively painless database portability, allows you to write your database access code in the same language as your application using strongly-typed objects and, in my opinion, allows you more flexibility in how you work with the data that you pull back.

Actually, being able to work with strongly-typed objects is reason enough to use an O/R Mapper.

Timothy Lee Russell
+1  A: 

I am a huge supporter of code over SPROC's. The number one reasons is keeping the code tightly coupled, then a close second is the ease of source control without a lot of custom utilities to pull it in.

In our DAL if we have very complex SQL statements, we generally include them as resource files and update them as needed (this could be a separate assembly as well, and swapped out per db, etc...).

This keeps our code and our sql calls stored in the same version control, without "forgetting" to run some external applications for updating.

Tom Anderson

Preference of stored procedures because: - enable fix some data related issues in production while system is running (this is num. one for me) - clean contract definition between DB and program (clean separation of concerns) - better portability to different DB vendor (if written well than code change is usually only on SP side). - better positioned for performance tuning

Cons - problematic in case WHERE clause has great variation in used conditions and high performance is needed.

+10  A: 

In my opinion you can't vote for yes or no on this question. It totally depends on the design of your application.

I totally vote against the use of SPs in an 3-tier environment, where you have an application server in front. In this kind of environment your application server is there to run your business logic. If you additionally use SPs you start distributing your implementation of business logic all over your system and it will become very unclear who is responsible for what. Eventually you will end up with an application server that will basically do nothing but the following:


Function createOrder(Order yourOrder) 
  Call SP_createOrder(yourOrder)

So in the end you have your middle tier running on this very cool 4 Server cluster each of them equipped with 16 CPUs and it will actually do nothing at all! What a waste!

If you have a fat gui client that directly connects to your DB or maybe even more applications it's a different story. In this situation SPs can serve as some sort of pseudo middle tier that decouples your application from the data model and offers a controllable access.

+1 - I wish I could up vote this a dozen times
"So in the end you have your middle tier running on this very cool 4 Server cluster each of them equipped with 16 CPUs and it will actually do nothing at all! What a waste!"Well, so forget about the "application server" and go for the Fat Database approach:
+1  A: 

I generally write OO code. I suspect that most of you probably do, too. In that context, it seems obvious to me that all of the business logic - including SQL queries - belongs in the class definitions. Splitting up the logic such that part of it resides in the object model and part is in the database is no better than putting business logic into the user interface.

Much has been said in earlier answers about the security benefits of stored procs. These fall into two broad categories:

1) Restricting direct access to the data. This definitely is important in some cases and, when you encounter one, then stored procs are pretty much your only option. In my experience, such cases are the exception rather than the rule, however.

2) SQL injection/parametrized queries. This objection is a red herring. Inline SQL - even dynamically-generated inline SQL - can be just as fully parametrized as any stored proc and it can be done just as easily in any modern language worth its salt. There is no advantage either way here. ("Lazy developers might not bother with using parameters" is not a valid objection. If you have developers on your team who prefer to just concatenate user data into their SQL instead of using parameters, you first try to educate them, then you fire them if that doesn't work, just like you would with developers who have any other bad, demonstrably detrimental habit.)

Dave Sherohman
+1  A: 

My vote for stored procedures; as an abstraction layer close to the data, efficient with sets, reusable by many "clients" (client languages). The T-SQL language is a bit primitive (and I guess that's what most of the C# guys here at SO have been exposed to), but Oracle's PL/SQL is on par with any modern programming language.

As for version control, just put the stored procedure code in text files under version control, then run the scripts to create the procs in the database.

+3  A: 

We use stored procedures with Oracle DB's where I work now. We also use Subversion. All the stored procedures are created as .pkb & .pks files and saved in Subversion. I've done in-line SQL before and it is a pain! I much prefer the way we do it here. Creating and testing new stored procedures is much easier than doing it in your code.



Pros to stored procedures 1). Improved security as the SQL in stored procedure is static in nature(Mostly). This will protect against SQL injection. 2). Reusability. If there is a need to return the same data for multiple applications/components, this may be a better choice instead of repeating the SQL statements. 3). Reduces calls between client and database server.

I am not sure about other databases but you can create stored procedures in host languages in db2 on mainframe which makes them very powerful.


Foot firmly in the "Stored Procs are bad for CRUD/business logic use" camp. I understand the need in reporting, data import, etc

Write up here...

+3  A: 

The following is a must read by SQL Server MVP Paul Nielsen:


For Microsoft SQL Server you should use stored procedures wherever possible to assist with execution plan caching and reuse. Why do you want to optimise plan re-use? Because the generation of execution plans is fairly expensive to do.

Although the caching and reuse of execution plans for ad-hoc queries has improved significantly in later editions of SQL server (especially 2005 and 2008) there are still far fewer issues with plan reuse when dealing with stored procedures than there are for ad-hoc queries. For example, SQL server will only re-use an execution plan if the plan text matches exactly - right down to comments and white space, for example, if each of the following lines of SQL were to be executed independently, none of them would use the same execution plan:

SELECT MyColumn FROM MyTable WHERE id = @id
select MyColumn from MyTable WHERE id = @id
SELECT MyColumn  FROM MyTable WHERE id = @id
SELECT MyColumn FROM MyTable WHERE id = @id -- "some comment"
SELECT MyColumn FROM MyTable WHERE id = @id -- "some other comment"

On top of this, if you don't explicitly specify the types of your parameters then there is a good chance that SQL Server might get it wrong, for example if you executed the above query with the input 4, then SQL Server will parametrise the query with @id as a SMALLINT (or possibly a TINYINT), and so if you then execute the same query with an @id of say 4000, SQL Server will parametrise it as an INT, and wont reuse the same cache.

I think there are also some other issues, and in honesty most of them can probably be worked around - especially with later editions of SQL Server, but stored procedures generally offer you more control.


Programmers want the code in their app. DBA's want it in the database.

If you have both, you can divide the work between the two by using stored procedures and the programmers don't have to worry about how all those tables join together etc. (Sorry, I know you want to be in control of everything.).

We have a 3rd party application that allows custom reports to be created on a View or Stored Procedure in the database. If I put all of my logic in the code in another application, I could not reuse it. If you are in a situation where you write all of the apps using the database, this isn't a problem.

Jeff O

Stored procedures can go out of sync between database and source control system more easily than code. The application code can too, but it's less likely when you have continuous integration.

Database being what it is, people inevitably make changes to production databases, just to get out of the woods for the moment. Then forget to sync it across the environments and source control system. Sooner or later, production db becomes the de facto record rather than the source control system - you get into a situation where you cannot remove any sprocs, because you don't know whether it's being used.

A good process should only allow changes to the production only through proper channels, so that you should be able to rebuild a database from scratch from the source control system (sans data). But I'm just saying just because it can be done and does get done - changes are made to production database at the heat of moment, between calls from yelling clients, managers breathing down your neck, etc.

Running ad-hoc queries is awkward with stored procedures - it's easier done with dynamic sql (or ORM), which may be the biggest drawback to using stored procedures for myself.

Stored procedures, on the other hand is nice in situations where you make a change but doesn't require re-deployment of app code. It also allows you to shape your data before sending it over the network where sql in code might have to make multiple calls to retrieve than shape it (although there are now ways to run multiple sql statements and return multiple result sets in a single "call", as in MARS in ADO.NET), resulting in probably more data travelling through your network.

I don't buy any other arguments regarding performance and security though. Either can be good or bad, and equally controlled.

Jiho Han
Why isn't your stored procedure in source control? Why don't you have unit tests for your database? In other words, why is your database not part of your CI environment?
John Saunders

I'm not a big fan of stored procedures, but I use them in one condition:

When the query is pretty huge, it's better to store it in the database as a stored procedure instead of sending it from the code. That way, instead of sending huge ammounts of string characters from the application server to the database, only the "EXEC SPNAME" command will be sent.

This is overkill when the database server and the web server are not on the same network (For example, internet communication). And even if that's not the case, too much stress means a lot of wasted bandwith.

But man, they're so terrible to manage. I avoid them as much as I can.