Using a GitHub Tagged Release for a Flyway Migration

Why not just build the latest version of any branch of the database by pulling the scripts from the latest tagged release on GitHub? While it is easy to get the files via the GitHub site, it gets tedious to do so repeatedly, via the GUI. It is, however, possible to automate this via the Rest API, using a script. If you are using PowerShell, I've done it for you. Read more

A Quick Diff Checker for SQL Server Databases

Compare the schemas of two SQL Server databases using SQL Compare command line then quickly produce a diff report showing you immediately which tables, views and functions have changed. Read more

Learn how to use Flyway for Automated Database Migrations

A learning path for managing and automating database deployments, from version control, using Flyway. Read more

Moving from application automation to true DevOps by including the database

This article explains the challenges of DevOps automation for databases, starting with how to manage the database, as a set of SQL scripts, in the version control system, and then how to start building an integrated and automated script pipeline for continuously testing and deploying database schema changes, alongside the application code. Read more

Automating SQL Compare Snapshots using SQL Snapper

If you have SQL Compare, then the SQL Snapper utility is very valuable 'extra' for certain team activities, because it can be freely distributed. It means that any developer can create a SQL Compare snapshot from databases that are on their local workstation and store them on the network. Read more

Using SQL Compare and SQL Data Compare within a PowerShell Cmdlet

SQL Compare and SQL Data Compare can be used together, from the command line, to provide a complete build process, or to script out changes to both the database and its development data. For doing this routinely, I find it easiest to script the operation using PowerShell. Read more

Maintaining a Database Build Script with SQL Compare

Phil Factor explores a lesser-known capability of SQL Compare, which is to help you maintain a 'traditional', well-documented, single file build script, for creating the current version of the database during development. Read more

Database Deployments and Rocky Rollback Horrors: Where Does the New Data Go?

Phil Factor describes the problem of preserving data that is left 'in limbo' when you need to revert the database to a previous version that has no way of accommodating it. Read more

Database Build Blockers: Four-part Object References

Cross-server references keep cropping up as a problem for development and build. Phil Factor demonstrates how using linked server 'aliases' can get around these issues, even if the individual databases use four-part references within the code rather than synonyms. Read more

Database DevOps for Pragmatists: A Datafaction Case Study

Ami Adler, a Software Development Manager at Datafaction explains how they used Redgate tools, and others, to introduce automation and testing into their Database DevOps processes and so achieved a faster and more reliable deployment process for their application. Read more

Comparing Two SQL Server Databases: When, Why, and How

SQL Compare has a simple premise: it will compare the two SQL Server databases for schema differences. It will generate a script that will make the schema of a target database the same as that of the source database. This article explores all the ways this can be helpful during database development and deployment, from generating database scripts in version control, to detecting database drift, to auto-generating deployment scripts. Read more

Solving the Provisioning Problem in Database Development using Clones

When database development is described, the details often get vague when the data gets beyond spreadsheet-size. There is 'hand-waving' talk of providing databases for each developer, but little detail of how you would provision all the databases that would be needed, at the correct version and with the correct development data, and then keep them all in sync with the source code, as developers commit changes. This article explains the requirements, and how SQL Clone can meet them. Read more

Questions about SQL Change Automation that you were Too Shy to Ask

Phil Factor takes on tricky SQL Change Automation questions about database builds, migrations, deployments and releases. Read more

Questions about Comparing Databases with SQL Compare that you were Too Shy to Ask

Phil Factor offers straightforward answers to tricky SQL Compare questions. Read more

Database Development with GitHub

How can you use GitHub to do team-based database development? This article proposes a process that splits development work into task-based GitHub branches, incorporates daily database builds and integration testing, and uses Redgate tools to automate tasks such as provisioning, database scripting, and testing. Read more

Using Filters to Fine-tune Redgate Database Deployments

Filters are used by Redgate's SQL Compare, SQL Source Control, DLM Dashboard, and SQL Change Automation. A typical use for a filter is to work on just one schema within a database or just a limited set of tables and routines. You would also want to use a filter to exclude certain object, such as database users, from comparisons. Phil Factor explains how they work, and how to create, edit and then use them within the various Redgate tools. Read more

SQL Change Automation: Adding SQL Clone to the Mix

Tony Davis explores how SQL Change Automation is increasingly providing ways of working with SQL Clone, to improve the quality of testing for database changes. With SCA v4.3, developers can now use the SSMS plugin to create a clone of the target database, to be used as a reference database, or baseline, for the deployment project. Read more

Deployment Suite for Oracle: What’s New? Git Integration in Redgate Change Control v3.0

In Redgate Change Control v3.0, you can now commit your database changes to your local Git repository and collaborate with your team by pushing and pulling changes from the remote Git repository. If you’re using branches, you can also create and switch Git branches from within Redgate Change Control. Read more

Handling System-named Constraints in SQL Compare

If some of your database constraints have system-generated names, they can cause 'false positives' when comparing schemas and generating build scripts using SQL Compare or SQL Change Automation. Phil Factor explains the difficulties, and the Compare option you need to enable to avoid them. Read more

Simple Database Development with SQL Change Automation

SQL Change Automation makes automation simple enough that it can adapt to suit many different approaches to SQL Server database development. Phil Factor describes a project to update the Pubs database, using it in combination with a PowerShell function and to maintain in source control the build scripts, migration scripts and object-level scripts, for every version of the database. Read more

Automating Oracle Database Deployments using the Hybrid Approach

Stephanie Herr explains how to use the 'hybrid' approach in the Deployment Suite for Oracle to automate Oracle database deployments. This is where the team maintains the current state of the database in version control during development. then, at key stages, they generate and test the migrations script that will be used to deploy the new database changes safely. Read more

Testing SQL Server Stored Procedures and Functions with SQL Data Compare

Phil Factor demonstrates a cunning way to test stored procedures or functions, such as after refactoring, by storing the 'before' and 'after' results in views and then using SQL Data Compare to spot any discrepancies. Read more

How to cope with Database Drift during Deployment using SQL Compare

Phil Factor on how to cope with any database drift that results from various checks and tests and fixes made during deployment. Read more

The Database Development Stage

Phil Factor distills the basic tasks of the database development stage and explains how SQL Compare can help tackle them. Read more

Getting Started with Automatic Database Branch Switching

Alexander Diab demonstrates how a team of developers can work on and test features in different branches of a SQL Server database development project, while their local development database automatically remains 'synchronized' with the current branch in version control. Read more

Deployment Suite for Oracle: What’s new? Redgate Change Automation

Redgate Change Automation is now part of the Deployment Suite for Oracle. It is a command line tool that makes it easier and safer to automate Oracle database deployments. It has four commands to help you build, test, prepare, and perform Oracle database releases with built-in safety checks. Read more

Allowing for manual checks and changes during database deployments

SQL Change Automation enables users to make database changes to production safely and efficiently using PowerShell cmdlets, which can be integrated easily into any release management tool. This article will show you how to automate database deployments safely, by using SQL Change Automation from within PowerShell scripts, and how a deployment script for a release can be checked and amended as part of the process. Read more

A Hybrid Approach to Database DevOps

A flexible approach to Database DevOps where the team maintain the current state of the database in version control, during development, and then at key stages generate and test the migrations script that will deploy the changes to the target database, safely. Read more

SQL Server Database Deployment: What Could Go Wrong?

Phil Factor tackles the tricky questions you will need to answer when deciding how to automate your SQL Server database builds and deployments with Redgate's development, version control and deployment tools. Read more

Build and fill a SQL Server Database using SQL Compare CLI and a Batch Script

Phil Factor provides a powerful DOS batch script which, when coupled with SQL Compare CLI, allows you to build databases from source, during development, and fill them with the specific datasets required for testing. Read more

Database Build Breakers: Avoiding Constraint Violations during SQL Server Deployments

A common database build breaker is data that violates the conditions of any of the CHECK, UNIQUE or FOREIGN KEY constraints, and unique non-clustered indexes, designed to protect the consistency and integrity of your data. Phil Factor explain how to avoid this problem, using SQL Compare and some custom stored procedures to discover which rows will cause violations, and fixing them, before running the build. Read more

Custom Deployments from Source Control using SQL Compare Command line

Giorgi Abashidze explains how his team use a 2-phase deployment process with SQL Compare Command line, and some SQL Synonyms, to automate custom deployments for each of their customers, while only needing to maintain one branch per release in source control. Read more

Deploying Data and Schema Together with SQL Compare or SQL Change Automation

You want to use SQL Compare or SQL Change Automation (SCA) to create or update a database, and at the same time ensure that its data is as you expect. You want to avoid running any additional PowerShell scripting every time you do it, and you want to keep everything in source control, including the data. You just want to keep everything simple. Phil Factor demonstrates how it's done, by generating MERGE scripts from a stored procedure. Read more

From Source Control to Database using SQL Compare Command Line

Giorgi Abashidze explains how his team use SQL Compare Command line to automate database deployments for their customers, without having access to the real staging or production databases, merely by using our development database contained under TFS Source Control. Read more

Using Custom Deployment Scripts with SQL Compare or SQL Change Automation

Phil Factor describes how custom pre- and post-deployment scripts work, when doing state-based database deployments with SQL Compare or SQL Change Automation, and how you might use them to, for example, add a version number to the target database, specify its database settings, or stuff data into some tables. Read more

Recreating Databases from Scratch with SQL Change Automation

Phil Factor starts with the basics how to rebuild a set of development database from scratch, using SQL Change Automation, and then demonstrates how to check for any active sessions before rebuilding, import test data using BCP, and secure passwords if connecting to the target with SQL Server credentials. Read more

Using the SQL Compare command line with Argfiles

Phil Factor demonstrates how using XML argfiles to pass parameters to SQL Compare cuts out a lot of the tedious scripting involved in modifying a database schema comparison and deployment process, as required for each target database. Read more

SQL Compare 14.0: A Command Line Interface on Linux and support for SQL Server 2019

SQL Compare is the industry standard tool for comparing and deploying database schema changes, and version 14.0 now provides a Command Line Interface (CLI) on Linux (available as a beta, at time of writing). Teams working with SQL Server on Linux, or across multiple platforms, benefit from seamless development processes, driven by SQL Compare, without Read more

Automating Schema Comparisons with SQL Compare Projects and PowerShell

A simple way of automating SQL Server database schema comparison and deployment tasks for multiple databases, by saving the options and configuration settings for each deployment in a project file and executing them from a PowerShell script. Read more

Comparing and Deploying SQL Server Databases using the SQL Compare Command Line on Linux or Windows

SQL Compare now includes a Linux-based command line interface (CLI), as well as a Windows-based one, for doing schema comparison and deployments of SQL Server databases. This article offers worked examples of CLI scripts for various schema comparison tasks, to get you up and running with either version. Read more

Handling Tricky Data Migrations during State-based Database Deployments

This article demonstrates how to use a 'state' approach to database source control, when the nature of the database changes cause you to hit difficulties with migrating existing data. These difficulties happen when the differences are such that it is impossible for any automated script to make the changes whilst preserving existing data. Read more

Integrating SQL Server Tools into SQL Change Automation Deployments

Phil Factor shows how to integrate use of SQL Change Automation, SSMS registered servers, SMO, and BCP to automatically build or update a database on all servers in a group. Read more

You just Build It don’t you? 12 Common Database Build Blockers

Database deployments, like the sheep of exasperated hill-farmers, often find strange and unexpected ways to self-destruct. Phil Factor describes the most common things that can go wrong, and how a reliable automated database build process can prevent messy accidents. Read more

Database Build Blockers: Cross-Server Database Dependencies

Phil Factor demonstrates how to tackle builds when databases make cross-server references. The technique uses synonyms to represent the remote objects, and local 'stub' objects to overcome the problems caused by 'missing references' when building the individual objects. Read more

Resolving Cross Database Dependencies in SQL Change Automation using Local Databases or Clones

How to avoid database build failures, caused by circular cross-database object references, by restoring or provisioning copies of all required databases to the development, build, or test SQL Server instance. Read more

Database Build Blockers: Mutually Dependent Databases

Phil Factor demonstrates a clever way to create 'stub' objects, in SQL Change Automation pre-deployment scripts, in order to overcome the problems caused by 'missing objects' when building databases that have circular, or mutual, dependencies. In the subsequent deployment, SQL Change Automation fully builds every object in each of the databases, so all dependencies are fully tested. Read more

Simple SQL Change Automation Scripting: The Release Object

Once you understand the SCA data objects, it can give you a certain glow of to discover, suddenly, that SCA can do some complicated and time-consuming tasks with just a few lines of code. Phil Factor demonstrates how to get the most of SCA's Release object. Read more

Simple SQL Change Automation Scripting: Connections, iProjects and Builds

Phil Factor delves into some of SQL Change Automation's data objects, or artifacts, covering the DatabaseConnection, iProject and iBuildArtifact objects. He explains the useful information they contain and how to use them in a PowerShell-automated database delivery process. Read more

SQL Change Automation Scripting: Getting Data into a Target Database

Your strategy for loading a freshly built database with data will depend on how much you need. If just a few rows, then single-row INSERT statements will be fine, but for more than that you'll need to build insert the rows using native-format BCP. Fortunately, SQL Change Automation (SCA) can be used with either strategy, as Phil Factor demonstrates. Read more

Static Data and Database Builds

Whichever way you wish to ensure that a database, when built, has all the data that will enable it to function properly, there are reasonably simple ways of doing it. Phil Factor explains the alternatives. Read more

Simple Steps in SQL Change Automation Scripting

Phil Factor demonstrates the bare essentials of SCA PowerShell scripts that can form the basis for an automated process for database delivery or help improve your current process. Read more

Database Delivery with Docker and SQL Change Automation

Phil Factor demonstrates how to integrate SQL Change Automation into containerized workflows, such as are typical of a microservices architecture. He shows how to automate database builds into a Linux SQL Server container running on Windows, and then backup the containerized database and restore it into dedicated containerized development copies for each developer and tester. Read more

Running Linux SQL Server as a Container

Phil Factor starts a series of articles that will demonstrate the use of temporary SQL Server instances, running in Linux containers, into which we can deploy the latest database build, stocked with data, for development and testing work. This initial article shows how to set up a SQL Server instance inside a Linux Docker container, create some sample databases, and persist data locally. Read more

How to create and refresh development and test databases automatically using SQL Clone and SQL Toolbelt

A PowerShell automation script to build a SQL Server database from source control, seed it with dummy data, document it, and then deploy copies to any number of test and development servers. Read more

Automating Builds from Source Control for the WideWorldImporters Database

Kendra Little shows how to get the WideWorldImporters database into version control, using SQL Source Control, and then set up an automated database build process, using Azure DevOps with SQL Change Automation. Read more

Database Continuous Integration with SQL Clone and SQL Change Automation

Phil Factor provides the basis for a Database Continuous Integration process, using SQL Change Automation to build the latest database, and then SQL Clone to distribute it to the various team-based servers that need it. Having honed the process, you can run it every time someone commits a database change. Read more

Build and fill a database using JSON and SQL Change Automation

Phil Factor demonstrates how to export data from a database, as JSON files, validate it using JSON Schema, then build a fresh development copy of the database using SQL Change Automation, and import all the test data from the JSON files. Read more

Database Continuous Integration with the Redgate SQL Toolbelt and Azure DevOps

Alex Yates shows how to set up automated processes for SQL Server database source control, build and continuous integration using Redgate SQL Toolbelt, Git and Azure DevOps Read more

Database Development in Visual Studio using SQL Change Automation: Getting Started

Steve Jones shows how to set up a SQL Change Automation (SCA) project in Visual Studio, and import an existing database. As the team make database changes, either in SSMS or VS, they import them into the SCA project, which saves each change as a migration script that is then committed to source control. Read more

Documenting your Database with SQL Change Automation

Phil Factor uses SQL Change Automation and PowerShell to verify that the source code for the current database version builds successfully and, if so, to generate web-based database documentation using SQL Doc. Read more

Practical PowerShell Processes with SQL Change Automation

Starting from the object-level source code for a database, Phil Factor shows how SCA can create a NuGet build package, use it to migrate target database to the same version, and publish web-based database documentation, a report of what changed on the target and the results of a static code analysis assessment. Read more

Deploying Multiple Databases from Source Control using SQL Change Automation

How to automatically build multiple test databases, from source control, and then fill them with standard test data sets, using SQL Change Automation, BCP and some PowerShell magic. Read more

SQL Change Automation with PowerShell Scripts: getting up-and-running

Provides a PowerShell automation script that will build a SQL Server database from the scripts in source control, document the database and then deploy it as a NuGet package, using it to update the schema of a live database. Read more

SQL Code Analysis from a PowerShell Deployment Script

This article shows how to define SQL code analysis rules using SQL Prompt and them run them automatically from a PowerShell script, displaying the detected code issues in a handy HTML report. Read more

What is SQL Change Automation?

This article describes the basic principles of SQL Change Automation, and how it works to provide a consistent and repeatable way of automating as much as possible of the database build, test, and deployment processes. Read more

SQL Compare Snapshots: a lightweight database version control and rollback mechanism

During the proof-of-concept phase of development work, SQL Compare Snapshots offer an easy way to work out what broke, if a change causes some tests to fail, as well as a simple ‘roll back’ technique to return quickly to the last working copy. Read more

A strategy for implementing database source control

Much has been written on the strategic benefits of having a database under source control though many articles are clear on “why” but conspicuously vague on “how”. Dave Poole tries to fill in some of the gaps. Read more

How to reformat a database in one operation

Inherited a database from another team? Changed your team policy on the way that you format SQL? What's to stop you formatting the code of an entire database nicely, when you're developing it? Manually, the process can take longer than you expect. Phil Factor demonstrates a simple 3-step approach to reformatting a whole database , in a single operation, using SQL Compare and SQL Prompt. Read more

Keeping track of history: SQL Compare and Temporal Tables

Asha Patel introduces SQL Compare 13's support for deploying changes to temporal tables, Read more

How to deploy changes to Azure SQL Database using SQL Compare and Azure Active Directory

Describing SQL Compare's built-in Active Directory Authentication mode, which makes it easier and more secure to, for example, deploy schema changes from version control to an Azure SQL Database. Read more

How to deploy a database plus static data using SQL Compare and SQL Data Compare

Tony Davis shows how to get a database, plus any static data, into source control, and then uses the "/include:StaticData" switch in the SQL Compare Pro command line, fromPowerShell, to automate the process of creating a new build script. Read more

Automating database deployments to and from source control using SQL Compare and PowerShell

How to use SQL Compare Pro command line with PowerShell to automate the processes of getting a new database into source control, updating the source with the latest database changes, creating a new build script for a database version, and creating a deployment script to synchronize an existing database with source. Read more

Automatically keeping ‘hotfix’ and production database schemas in sync

How to use the SQL Compare Pro command line to automatically compare the schema of two versions of the same database, and then subsequently deploy to the target database any differences detected in the source database. Read more

How to build-and-fill multiple development databases using PowerShell and SQL Data Generator

This article offers a build-and-fill method for development databases, where each developer will subsequently want to alter the data or metadata in his or her copy of the database. Read more

How to Automatically Fill your SQL Server Test Databases with Dummy Data

A PowerShell script to automatically populate a SQL Server database with dummy data, for database development and testing work. Read more

How to build multiple database versions from the same source: pre-deploy migration scripts

The final part of Alex Yates's three-part series tackles the complicated issue of automating deployments when the same table might have a different structure, in different production versions of the database. Read more

Automating DacPac deployments using the SQL Compare command line and PowerShell

How to extract a database migration script, or a database build script, from a DacPac and then use it in a PowerShell-automated database deployment. Read more

How to build multiple database versions from the same source: post-deploy scripts

In Part 2 of his series, Alex Yates shows how to use a combination of post-deployment scripts to handle cases where a code object exists in multiple production instances, but in different states. Read more

Database CI with Redgate SQL Change Automation, PowerShell and Jenkins

Alex Yates shows how to set up automated processes for SQL Server database source control, build and continuous integration using Redgate SQL Toolbelt, Subversion, and Jenkins Read more

Deploying schema changes to multiple databases using the SQL Compare command line

How do you push out the schema changes to ten copies of the database on ten different servers, as part of a deployment? Read more

How to build multiple database versions from the same source: object filters

How to use filters in SQL Compare to avoid deploying objects that exist only in the source to databases where they may not be required or appropriate. Read more

How to version control a database using GitHub and SQL Source Control

This article explains some simple steps to create a GitHub database repository and then version control your SQL Server database, for team development work, using SQL Source Control. Read more

Comparing SQL Server Databases using DacPacs and SQL Compare

How to compare SQL databases using DACPACs, script out differences and then run a database deployment task to synchronize the schema of the target database. Read more

SQL Deployment Automation using SQL Compare Command Line

SQL Compare provides a command line interface (CLI) for running database schema comparisons and generating a deployment script, as part of a scripted process. I'll demonstrate how to do this with a 1-click process, using a batch (.bat) file. Read more

Using SQL Compare with In-Memory OLTP tables

SQL Compare can help you compare two databases that have In-Memory objects, the tables, their indexes and any natively-compiled procedures, and generate the appropriate scripts. Read more

Using SQL Compare with Row Level Security

As you test your row-level security in various environments, you can use SQL Compare to script out and deploy those changes to other databases. Read more

Using SQL Compare with Dynamic Data Masking

SQL Compare works with dynamic data masking, detecting the differences in masks across tables and generating the T-SQL you need to deploy your masking configuration to other databases. Read more