It avoids sub-selects and the hidden selects of recursive CTEs and is going to be relatively quick. By "relatively quick" I mean it's going to be about as fast as your disks or CPUs, whichever is slower. This will fall down if there's a possibility that multiple values of a property can exist for a single ID. E.g. Sources 1 and 3 have a value for Property3.

My favorite rackspace memory was when they mistakenly turned off the active server in an active passive cluster. Normally this would have been fine, but we had to take the passive server offline because of their bad set up, which was preventing failover from happening.

This is why I continue to use spacemacs. Sure, there are trade-offs. And sometimes I may not be able to immediately use something the way a tutorial demonstrates, but there's a great community and I don't have to reimplement the wheel. (My wheels are often oval or even triangles, too.)

I'm not saying that you can't be successful with a single database with multiple tenants, but I am saying that experience has taught me this solution poses many operational challenges that most people do not overcome. Of the multi-tenant SQL Server applications I've worked with in the last 5 years, all of them were either using the database-per-tenant approach or were migrating in that direction as fast as they could.

The big dangers of the approach you describe come from bad plans and parameter sniffing. Let's say you've got one client with twice as much data as the others. They run a stored procedure first. That procedure is compiled in ways that make sense for them (large memory grants, hash joins, all that fun stuff). When other, smaller tenants run that same procedure they get the plan that assumes a large amount of system resources are being used. This causes all kinds of problems for system level performance.

Also, as long as there are humans writing code, there can be screw-ups. Someone will eventually hard code a client value because they copy-pasted from development into production or you'll hit a query generation bug. Or you'll use OPTION (RECOMPILE) to get around parameter sniffing which has had a bug on three occasions where you can get someone else's query results. Here's one example.

Row-level security might be good, but it relies on a developer writing an effective discriminator function based on the user or based on the CONTEXT_INFO value (which is a hex value). The RLS functionality requires that you use a multi-statement table-valued function (a user could have multiple roles). Multi-statement table-valued functions also cause some hilarity for the optimizer - it assumes that 100 rows will come back, no matter what. (SQL Server 2012 and earlier only assumes 1 row will come back.)

If you mean SQL Server encryption, the other gotcha is around encryption.
* TDE is only encryption at rest - doesn't protect you.
* Always Encrypted only allows for equality searches - not really useful.

And, one last fun one, in many multi-tenant applications, it's nice to migrate customers to a new feature slowly so that you don't have to take everyone offline while you modify a large table. The easiest way to do that is with rolling releases across the many tenant databases.

Security is only one concern when you're looking at a multi-tenant system. They're complex beasts. Managing 100 databases may seem like a chore now, but there are many ways to solve that problem and they are well defined solutions. Managing 1 large database with many different use patterns is difficult and requires serious development investment just to keep existing functionality running well, and you'll obviously need more development time to add new features, too.

The upside of a Mac is that it has a decent terminal so you can remotely access the lab systems, which are running Linux. Homebrew is great to start with on the Mac, but eventually some aspect of OS X's ancient tooling will bite you in the ass.