Home » excel » Getting a significant amount of data into a SQL Server (Express) database at time of deployment

Getting a significant amount of data into a SQL Server (Express) database at time of deployment

Posted by: admin May 14, 2020 Leave a comment


For most database-backed projects I’ve worked on, there is a need to get “startup” or test data into the database before deploying the project. Examples of startup data: a table that lists all the countries in the world or a table that lists a bunch of colors that will be used to populate a color palette.

I’ve been using a system where I store all my startup data in an Excel spreadsheet (with one table per worksheet), then I have a utility script in SQL that (1) creates the database, (2) creates the schemas, (3) creates the tables (including primary and foreign keys), (4) connects to the spreadsheet as a linked server, and (5) inserts all the data into the tables.

I mostly like this system. I find it very easy to lay out columns in Excel, verify foreign key relationships using simple lookup functions, perform concatenation operations, copy in data from web tables or other spreadsheets, etc. One major disadvantage of this system is the need to sync up the columns in my worksheets any time I change a table definition.

I’ve been going through some tutorials to learn new .NET technologies or design patterns, and I’ve noticed that these typically involve using Visual Studio to create the database and add tables (rather than scripts), and the data is typically entered using the built-in designer. This has me wondering if maybe the way I’m doing it is not the most efficient or maintainable.


  1. In general, do you find it preferable to build your whole database via scripts or a GUI designer, such as SSMSE or Visual Studio?

  2. What method do you recommend for populating your database with startup or test data and why?


Judging by the answers so far, I think I should clarify something. Assume that I have a significant amount of data (hundreds or thousands of rows) that needs to find its way into the database. This data could be sourced from various places, such as text files, spreadsheets, web tables, etc. I’ve received several suggestions to script this process using INSERT statements, but is this really viable when you’re talking about a lot of data?

Which leads me to…

New questions

  1. How would you write a SQL script to take the country data on this page and insert it into the database?

    With Excel, I could just copy/paste the table into a worksheet and run my utility script, and I’d basically be done.

  2. What if you later realized you needed a new column, CapitalCity?

    With Excel, I could take that information from this page, paste it into Excel, and with a quick text-to-column manipulation, I’d have the data in the format I need.

I honestly didn’t write this question to defend Excel as the best way or even a good way to get data into a database, but the answers so far don’t seem to be addressing my main concern–how to get all this data into your database. Writing a script with hundreds of INSERT statements by hand would be extremely time consuming and error prone. Somehow, this script needs to be machine generated, but how?

How to&Answers:

I think your current process is fine for seeding the database with initial data. It’s simple, easy to maintain, and works for you. If you’ve got a good database design with adequate constraints then it doesn’t really matter how you seed the initial data. You could use an intermediate tool to generate scripts but why bother?

SSIS has a steep learning curve, doesn’t work well with source control (impossible to tell what changed between versions), and is very finicky about type conversions from Excel. There’s also an issue with how many rows it reads ahead to determine the data type — you’re in deep trouble if your first x rows contain numbers stored as text.


1) I prefer to use scripts for several reasons.

• Scripts are easy to modify, and plus when I get ready to deploy my application to a production environment, I already have the scripts written so I’m all set.

• If I need to deploy my database to a different platform (like Oracle or MySQL) then it’s easy to make minor modifications to the scripts to work on the target database.

• With scripts, I’m not dependent on a tool like Visual Studio to build and maintain the database.

2) I like good old fashioned insert statements using a script. Again, at deployment time scripts are your best friend. At our shop, when we deploy our applications we have to have scripts ready for the DBA’s to run, as that’s what they expect.

I just find that scripts are simple, easy to maintain, and the “least common denominator” when it comes to creating a database and loading up data to it. By least common denominator, I mean that the majority of people (i.e. DBA’s, other people in your shop that might not have visual studio) will be able to use them without any trouble.

The other thing that’s important with scripts is that it forces you to learn SQL and more specfically DDL (data definition language). While the hand-holding GUI tools are nice, there’s no substitute for taking the time to learn SQL and DDL inside out. I’ve found that those skills are invaluable to have in almost any shop.


Frankly, I find the concept of using Excel here a bit scary. It obviously works, but it’s creating a dependency on an ad-hoc data source that won’t be resolved until much later. Last thing you want is to be in a mad rush to deploy a database and find out that the Excel file is mangled, or worse, missing entirely. I suppose the severity of this would vary from company to company as a function of risk tolerance, but I would be actively seeking to remove Excel from the equation, or at least remove it as a permanent fixture.

I always use scripts to create databases, because scripts are portable and repeatable – you can use (almost) the same script to create a development database, a QA database, a UAT database, and a production database. For this reason it’s equally important to use scripts to modify existing databases.

I also always use a script to create bootstrap data (AKA startup data), and there’s a very important reason for this: there’s usually more scripting to be done afterward. Or at least there should be. Bootstrap data is almost invariably read-only, and as such, you should be placing it on a read-only filegroup to improve performance and prevent accidental changes. So you’ll generally need to script the data first, then make the filegroup read-only.

On a more philosophical level, though, if this startup data is required for the database to work properly – and most of the time, it is – then you really ought to consider it part of the data definition itself, the metadata. For that reason, I don’t think it’s appropriate to have the data defined anywhere but in the same script or set of scripts that you use to create the database itself.

Test data is a little different, but in my experience you’re usually trying to auto-generate that data in some fashion, which makes it even more important to use a script. You don’t want to have to manually maintain an ad-hoc database of millions of rows for testing purposes.

If your problem is that the test or startup data comes from an external source – a web page, a CSV file, etc. – then I would handle this with an actual “configuration database.” This way you don’t have to validate references with VLOOKUPS as in Excel, you can actually enforce them.

  • Use SQL Server Integration Services (formerly DTS) to pull your external data from CSV, Excel, or wherever, into your configuration database – if you need to periodically refresh the data, you can save the SSIS package so it ends up being just a couple of clicks.
  • If you need to use Excel as an intermediary, i.e. to format or restructure some data from a web page, that’s fine, but the important thing IMO is to get it out of Excel as soon as possible, and SSIS with a config database is an excellent repeatable method of doing that.
  • When you are ready to migrate the data from your configuration database into your application database, you can use SQL Server Management Studio to generate a script for the data (in case you don’t already know – when you right click on the database, go to Tasks, Generate Scripts, and turn on “Script Data” in the Script Options). If you’re really hardcore, you can actually script the scripting process, but I find that this usually takes less than a minute anyway.

It may sound like a lot of overhead, but in practice the effort is minimal. You set up your configuration database once, create an SSIS package once, and refresh the config data maybe once every few months or maybe never (this is the part you’re already doing, and this part will become less work). Once that “setup” is out of the way, it’s really just a few minutes to generate the script, which you can then use on all copies of the main database.


Since I use an object-relational mapper (Hibernate, there is also a .NET version), I prefer to generate such data in my programming language. The ORM then takes care of writing things into the database. I don’t have to worry about changing column names in the data because I need to fix the mapping anyway. If refactoring is involved, it usually takes care of the startup/test data also.


Excel is an unnecessary component of this process.

Script the current version the database components that you want to reuse, and add the script to your source control system. When you need to make changes in the future, either modify the entities in the database and regenerate the script, or modify the script and regenerate the database.

Avoid mixing Visual Studio’s db designer and Excel as they only add complexity. Scripts and SQL Management Studio are your friends.