DB change management does not cash related to the selection of version control systems, as long as you've one to begin with. Obviously, if you work with change management tools from MS you may be quite certain they have been examined against TFS and also the relaxation from the MS developer stack very well. That's true whether you utilize DBPro or even the far older/crappier types of integration observed in the classic Versus "database project" or perhaps in SQL Management Studio's removed lower project/solution bindings. There is however pointless you cannot use DBPro with Subversion, or Red-colored Gate with TFS for your matter.

Same applies to build generation. CC.Internet versus Team Build, NAnt versus MSBuild, etc...the state MS tools are usually roughly on componen using the competition. You have not referred to your DB deployment process in much detail however i can't fathom it might be considerably harder to script in MSBuild than you are using now, if whatsoever. Nor could it be difficult to distinct toolsets at different points within the stack: you could have CC.Internet drive MSBuild-based develops designed to use Red-colored Gate's command line deploy, or other combination. I occur to think the tight integration provided by adhering towards the MS world far exceeds the eccentricities in almost any one tool, however the option is there.

Allow me to become so terrible: it may sound much like your primary issue is not technical, but getting DBAs to really adopt version control to begin with. In case your "dev" and "push" conditions are their very own living organizations, instead of generic machines defined solely by caused by some repeatable build process, then you are not necessarily using version control in my opinion. Let's suppose a customer developer from time to time hands-tweaked the DLLs on various machines around the organization, then complained that they are way too hard to synchronize you'd think he was crazy.

Beyond that, the most crucial investment is dealing with a location where there is nothing ever completed to a DB directly (anymore than you'd poke around in %programfiles%). When not within the source repository, it does not exist.

I do not think the way you get there's as vital. You can write all your Produces and ALTERs in Notepad, check them in in the command line, and also have your "build process" be considered a 2-line spend script that concatenates them right into a well-known file in which the deploy script knows to appear. Or you might make use of a fancy tool like DBPro to amplify your productivity with intellisense / unit testing / offline modeling / etc. You will find great good reasons to mind within the latter direction (particularly if you believe declarative programming is one thing to shoot for generally), but I do believe the initial step may be the greatest.

We are using Visual Studio 2008 Team Suite together with TFS. I could import our databases into TFS with relative ease. However, I have discovered that the majority of the team (such as the DBAs) does not remember to update TFS once they modify an item in SQL.

Any type of build process will depend on DB Professional to create difference scripts involving the dev atmosphere and also the target atmosphere. I have discovered that this really is problematic because our dev atmosphere isn't a clean match to the production atmosphere. Permissions are extremely various and we have many other cases when changes were used in dev/QA but never moved to push (but were also never corrected). Attempting to isolate your changes from a lot of other alterations in DB Professional is challenging since it the UI enables you to exclude objects in the final script (if you modify 2 objects and 1000 other medication is different, you need to uncheck another 1000 objects). Additionally, configuration from the schema comparison is frequently completed in tools->options whereas other tools like Red-colored Gate permit you to configure the comparison on a single screen that you simply start it.

I believe the tool has potential but we certainly have to adapt our existing methods and systems to utilize TFS. Additionally, getting versioning in your database objects is invaluable, even when it isn't 100% current.