Yeah, me neither…

<this is your cue to chuckle a bit, because I think we’ve all done it a time or two>

In fact, it was Karen Lopez (twitter | blog) who got me looking for this script, and I thought I’d put it out there.  Nothing proprietary about it – it’s just a script to find a backup – but it can be useful when you’re trying to find out where in all the clutter of files you’ve got on boxes the one backup you actually need really is.

At any rate, some time ago I wrote this script that showed me where the last backup was of a database – run from within that database.

Take a look – let me know what you think.  If you can improve it, by all means, feel free to let me know that too.  Enjoy.

DECLARE @BACKUPNAME SYSNAME
SELECT @BackupName = (
SELECT     TOP (1) backupmediafamily.physical_device_name
FROM         msdb.dbo.backupmediaset AS backupmediaset_1
INNER JOIN        msdb.dbo.backupmediaset
ON                msdb.dbo.backupmediaset.media_set_id = backupmediaset_1.media_set_id
INNER JOIN        msdb.dbo.backupset
ON                msdb.dbo.backupmediaset.media_set_id = msdb.dbo.backupset.media_set_id
AND                backupmediaset_1.media_set_id = msdb.dbo.backupset.media_set_id
INNER JOIN      msdb.dbo.backupfile
INNER JOIN        msdb.dbo.backupfilegroup
ON                msdb.dbo.backupfile.backup_set_id = msdb.dbo.backupfilegroup.backup_set_id
ON                msdb.dbo.backupset.backup_set_id = msdb.dbo.backupfile.backup_set_id
AND             msdb.dbo.backupset.backup_set_id = msdb.dbo.backupfilegroup.backup_set_id
INNER JOIN        master.sys.sysdatabases
ON                backupset.database_name = master.sys.sysdatabases.name
INNER JOIN         msdb.dbo.backupmediafamily
ON                msdb.dbo.backupmediaset.media_set_id = msdb.dbo.backupmediafamily.media_set_id
AND             backupmediaset_1.media_set_id = msdb.dbo.backupmediafamily.media_set_id)
print        ’backupname ‘
print        @backupname

It went something like this:

Male logic

One… <click>

Two…<click>

Three…<click>

… all the way up to 10.

It was simple, elegant, and – to be honest, some might consider it a little boring…

Female logic

Now female logic, he said, was a lot different – and, as much as people want to think men and women are the same, we’re not – not by a long shot.  He pointed out that giving a female the very same 10 step process, she’d go at it like this:

One…<click>

Fourteen…<click>

10.

How the heck did that happen?

In fact, ladies out there – how do you do that?

See – that 14 is COMPLETELY outside our frame of reference, we don’t think about it – it’s not there.  We can ask you how or why it happens, but explaining to someone the concept of 14 when the numbers only go up to 10 is just baffling to us guys – and the way you relate things together that have you making connections and drawing conclusions that we might not see gives you a stunning edge in some incredible areas.

Call it intuition.  Call it what you will, but and it’s like women have a math coprocessor or something so they can shove a problem over there, let it get solved, and come back in a bit with an answer that even they don’t know how they got.

And often the guy’s on step 3, the gal’s at 10,

In fact, I gave the bulk of this blog post as part of a presentation once and got an astonishing piece of feedback from a woman who had “made it” in the industry.  It came to me sanitized, and I couldn’t tell you who it was if I wanted to, but what you read above was written by a guy, me.  What you’ll read below was written by a gal, is in her words, and she quite literally wished to remain anonymous.

When I ended up in the technology industry, I was usually the first female technical peer any of the guys had worked with, and the first technical female any of the (universally male) managers had tried to manage, and it gets ugly when you’re asked for status and all of the guys are all at steps 2-4 and you’re doing something … completely different.   It’s ugly then, and it’s uglier when, without being able to explain it or teach it … you get at least the same result, faster.  And as you gain confidence, much faster. I still remember being assigned to teach a pretty talented guy who have had all the right experience and skills, how to triage a network sniffer trace.  In my mind it starts with “you scroll quickly through the packets looking for something that’s not quite right” … and I knew the exercise was doomed when I looked at his notebook and he’d neatly written “Step 1.” I knew then I would never be able to explain the concept of not really reading, just relaxing with cup of coffee and scrolling through, knowing that your subconscious will throw up an alert if it sees something that’s “not quite right”. There’s your “skip to #14″ bit – I can write or use a parsing app for a network trace, but before I go the effort, I’ll just use my eyes.  Sit back with a cup of coffee and scroll through the trace, looking for patterns that “aren’t quite right”.  I’m not looking closely, I haven’t the slightest notion what I’m looking for, and when something strikes me as “not quite right” it can take me some time to figure out exactly why, but it’s often not the sort of thing I could have ever found using traditional analytics and parsing tools.

I was just thrilled to find this info.  It proved my point, not that men are better or women are better. But that they’re different, and that difference needs to be recognized, acknowledged, even if, as guys, we may not completely understand it.

In fact, please understand – this is not a jab at either gender.  There’s no way I’d say one is right or wrong, they’re just different.   And this whole “14” thing – women seeing/feeling/perceiving relationships intuitively where men might not see them in the same way, I think, honestly, that’s why, while IT is traditionally a male dominated field, that database administration (hint: relational databases…) seems to have a greater percentage of females in it.

So, is there more to the story? Yes, there is.

In a nutshell: just because a guy doesn’t understand the existence of 14 doesn’t mean her 14 isn’t valid.

And just because a gal can’t explain the 14 to a guy doesn’t mean he’s an idiot.

It takes a wise manager to see that the problem-solving skills that employees bring to the technical table, whether 1-2-3-4-5-6-7-8-9-10 or 1-14-10, can actually be quite complimentary.

He was also at this stage in life where he just wanted to do everything by himself – and, for those of you who have children, you’ll recognize some of this, too.

He was a “big boy” now, and he wanted to take care of things in a “big boy” way, so when he had to go take care of some, shall we say, personal business, he wanted to do it, as he said, “all by myself”.

And so, like many parents, I waited for him to call me and tell me he was done, so I could help him finish up the paperwork, so to speak.  And he didn’t call, and didn’t call, and didn’t call.

Finally I called in and asked if he was okay.  I heard a strained, “I’m fine!” – and then silence.  Then I heard a thump, followed by another thump.

Hmmm…

Silence followed by thumps is never good.  It seemed like it was time to go check on him, so I rushedin to see what was the matter – and in half a second I could see what had happened.

He’d been sitting on the toilet – the “grownup” toilet that everyone else used, not the little one he would normally use, and he’d been holding himself up with his hands to keep from falling in.

When he was done, wanting to be a “grownup”, he skootched himself forward until he could get off, but in doing so, left quite a bit of “evidence” on the toilet seat, the front of the toilet, and all the way up his back that he’d done so.  It was clear he’d lost his balance a bit as he was trying to stand and had bumped into the wall, leaning there to hold himself up.

The, um,  evidence was there, too.

He was standing there in the middle of the bathroom, ‘pullups’ down around his feet, surveying the scene when I rushed in and saw the whole thing.  I could clearly see what had happened based on what I just described, but instinctively wanting to confirm it, I blurted out, “Michael!  What happened?!”

His answer was priceless…

“Well, Papa.  Sometimes… things go wrong.”

There it was, plain and simple. “Sometimes, things go wrong.”

Despite the best of intentions, despite the best will in the world, as he said, “Sometimes, things go wrong.”

People make mistakes, or don’t live up to our expectations.

Things go wrong.

Things break, or don’t work like we expect.

Things go wrong.

No matter what we do in life…

Sometimes…

Things go wrong.

So how do you handle it when they do?

And, when you have a simple acknowledgement of the fact up front, how on earth can you be angry?

How do you – at work or at home – handle it when things go wrong?

What, if you were faced with that situation I mentioned, would be the most important thing?

Seems like they’d be like this, in order:

1. Clean up Michael (as in: clean up the source of the – we’ll call it “evidence”)
2. Clean up the toilet seat (as in: make sure things are functional again)
3. Clean up the wall (as in: take care of any – we’ll call it ‘collateral damage’ here)
4. This one’s incredibly important: Remember:  sometimes, THINGS GO WRONG – equipment breaks or wears out, code for our computers has bugs in it, and humans, both personally and professionally, are not perfect.

Yelling at my son about making a mess he already told me he didn’t mean to make wasn’t going to solve anything.

Managers yelling at employees when things go wrong generally don’t have much of a good result either, nor, often, does yelling in personal situations.

The important thing there was to help clean up the mess, then reassure him and let him know that everything was okay.  Just like you need to reassure and encourage the people involved so they’re not afraid to, shall we say, ‘get back in the saddle’.

And this takes us to…

5.     if you want to keep this kind of thing from happening again:

Personally: I can’t stress the importance of communication – not just speaking, but being willing to listen.  I’ll be the first to admit I’m not perfect in this and have definitely made my share of mistakes.

And realize yours might not be the only right view there.  (Yes, hard as it is to understand this in the moment,  it’s possible for two people to be right about something – and still disagree with each other). Often, one will be thinking short term, one long term.  Or, one may be thinking, we’ll call it ‘rationally’ while the other is thinking ‘emotionally’.

Note: One is just as valid as the next.

Professionally: Communication here is just as critical.  You might have one person thinking long term, but unable to articulate it, while another is focused on the immediate problem, and is more vocal.

Both are valid.

Be sure to listen to the quiet people in your organization.  Make sure your people are equipped with the proper tools to do the job they’re expected to do.  Going back to my son’s analogy, it’s good to make sure the saddle’s the right size in the first place.  Instead of your people using all their strength to keep from falling into a place they’d rather not be because the hole – or the responsibility – is too big, make sure they have the skills (read: training)  to be big enough to keep from falling in in the first place.

Does that make sense?

There are many ways to handle situations like this, but for those of you doing management of some kind, understand that the minds of your employees are the most vital things you have.  Most often, it’s in there that the solutions to the problems lie.  Making them quake in fear of you isn’t a productive use of your time, isn’t a productive use of their skills, and doesn’t make them feel comfortable getting, as I said, ‘back in the saddle’.

So.

Respect them for their skills.

Forgive them for their mistakes.

Put the past where it belongs, behind you, and in doing so, you’ll help them learn, and you’ll teach them something far, far more valuable than you realize.

You’ll teach them they can trust you to have their back when they need you.

You’ll teach them they can take risks and fail, and not worry about their jobs.

But in setting them up like that – they’ll also feel comfortable right at the edge of their skill envelope, and, as one leader (the former CIO of the company I work for (yes, this means you, Dale) once said, “it’s when you’re at the edge of your envelope that you make mistakes, but that’s also where you learn the most.  Yes, sometimes you fail, but sometimes you succeed beyond your wildest dreams.”

He was right, and I appreciated that sentiment more than I ever really found words for.

It also boggled my mind that someone, with all the education he had, with all the experience he had, at the peak of his career in a company could come to the same conclusion that my then two year old son came up with on his own.

It shouldn’t be that hard for those of us somewhere between the two to come to similar conclusions, should it?

in fact, it seems like a huge part of success comes from understanding, and accepting, that…

Sometimes…

Things go wrong.

Interesting concept – this SQLfamily thing, one I hadn’t really thought of, but the longer I stay in it, the more I understand it, and the more I learn there is to understand.

When I first started out in IT, I found myself reaching up to the people who’d been here longer than me, always reaching, learning, growing.

I’ve found that lately, while the reaching, learning and growing hasn’t stopped, there’s another aspect to it now.  I’m reaching, learning and growing – but reaching back, and learning a lot by teaching some of the people who are coming up the ranks behind me.  I learn so much from teaching, because I actually have to explain why I do something, and often, in that very act – understand it better myself.

I can’t tell you how many times the exercise of having to explain something has helped me understand it – even if it’s trying to explain a problem I’m having and am asking for help on.  One place I worked, the lead dba there would see me show up at his desk, with a puzzled look on my face, say thank you, and leave (leaving my puzzled look on his face).  Turns out that just in trying to figure out how to ask him the question, I’d figured it out for myself.

I’ve dealt with folks who are wonderful at answering questions, and folks that taught me much, not only in the basics, but also learning how to learn.

I’ve also dealt with folks who are the SQL equivalent of curmudgeons (nicest word I could think of) – and like it or not, learned from them.

It’s just like a regular family.  Some functional… some dysfunctional… All the wonderful fruits and nuts we’re used to dealing with in our own families.

And that’s part of it, right? We’re all human, we make mistakes, and things go wrong, often at the worst possible moment.  Having that SQL family out there is like having someone you can depend on – even if it’s not technical, but “just” moral support.

In fact, I’m training a new fellow here in the company, we’ve been troubleshooting a horked out master database on an old box that should have been put out of our misery a long time ago, and of course, I’m trying to distill years of “don’t believe the UI” into a simple “because” statement, and it’s challenging – but he’s part of the SQL family, and so while I teach him, he helps me, and it turns out he’s training others.

And that’s cool.

It’s… It’s a “Circle of Life” kind of thing…

There are a few applications that are mind bending in how useful they are, how they connect dots that were never connectable before, but for the most part, I cannot bring myself to utter the word “cool” about most of the software out there.

I’ll tell you why – and as always it begins with a short story.

Back in – well, a few years back… my sister and I worked for a little software company that had been started by a couple of college dropouts and was being run in a small town just east of Seattle.

She and I had both also managed to drag our parents out of what we thought was the stone age and had gotten them a computer, and we spent hours, days, weeks going over and over and over with them what an “icon” was, the concept of “clicking and dragging”, and the realization that “just because you didn’t see it, doesn’t mean it’s gone.”  I’m sure some of you out there have worked with your parents in this way.  Doing “support” calls, leaning back in your chair, eyes closed, one hand holding the phone, the other holding your head, the bottle of aspirin nearby, trying to project this voice of calm and reason to a parent who simply doesn’t “get it”.

Now – understand – this is not to slam parents or their generation.  Oh, Lordy – That’s the last thing I’d want to do.  The thing that’s difficult is translating what you know and take for granted into something that’s so unfamiliar to them (if they can’t see it and feel it, it must not be there, right?) to something they can relate to and understand – without having them go over the edge in frustration.  I’ve had a couple of calls with my mom that lasted two hours (almost as much time as it would take to drive down there, do it, and drive back) – and they were often things we in the IT world would call ridiculously simple – copying and pasting, for example, was one thing my mom’s had trouble with.  But try explaining it to someone without using computer terms – to someone who grew up in another country, another culture, who’s never actually copied and pasted – and it becomes a bit of a challenge, and you have to make sure the concept itself is clear before you try to explain the mechanics of it.  She’s got a device that allows her to browse the Web from her TV as well as that computer we got her – and of course the commands for one can’t be consistent with the commands for the other – so that makes it hard to assume that something will just simply work as you expect it to.  It can get frustrating – on both sides.

But a little note – nay – reminder for anyone out there who gets frustrated at explaining something technical to your parents – well, I can’t speak for your parents specifically, so I’ll speak generally:

These are the folks who quite literally dealt with your crap.  These are the folks who changed your diapers, who changed work schedules to take you to or be at your school events growing up, who fixed thousands of sack lunches, who helped with last minute school projects, who listened to your dreams as you became a teenager, and did what they could to keep food on the table, and a roof ­­­over your head… And they smiled that proud, gut wrenchingly bittersweet smile parents get as they watched your car – or bus – or whatever – leave that one time that neither of you really knew would be the last time you’d ‘live at home’ – A little bit of a support call to help them out is the least I can do.   I do not for one moment regret the time spent on the calls I get from my mom on computer problems.

After about a year and a half, mom and dad knew how to use the computer, the “support calls” were fewer, and they were actually able to write letters and stories and the like.  It was kind of a neat feeling – almost like the shoe was on the other foot – me watching them “grow up” – so to speak, instead of them watching me.

But one day, at work, when a developer wanted to show me something new he’d written – I just about flipped.

See, he’d written this snippet of code, that did something… and to this day I can’t remember what it was – but he ran it, showed me what it did, and then said, with eyes just beaming with excitement, “Tom, isn’t that COOOOOOOOL?”

I understand that feeling.  I’ve written little snippets of code that solve problems in rather ingenious ways – but even as I sit here, writing this, I still remember that sinking feeling I had in the pit of my stomach when I heard him say that…

Given where I worked, and given what I knew of software development, I knew that this little “cool” thing would make it into an operating system at some point, and soon.

And it would fundamentally change how my parents had to work.  And it would mean more telephone calls, to explain something that someone had changed.

Not because it made something better.

Not because it made it easier.

Not even because it made it faster.

But because it made something “cool”.

See, there seems to be a misunderstanding of the purpose of writing software.

My take is that you write software to use it.  And if you use it at work, it should make your work faster, more efficient, more streamlined.  If you use it at home, it should solve problems and make it take less time to do things (think putting together a photo album, balancing your checkbook, or trying to find out where your 401K went).

Here’s the deal: Software Should Simply Work.

Period.

Make it do what it’s supposed to do first.

If developers write code with the understanding that it is to be used by people, and that it should make their lives easier – then they have it nailed.

If developers write code only to show off their prowess, or only to show off their ingeniousness to other developers, then they’ve forgotten who their audience is, and that misses things entirely.

So… what’s ‘cool’?

An application that solves a problem and does it well.

That’s cool.

An application that is easy to learn and intuitive for a first time user, and at the same time, just surprises you with deeper and deeper little snippets of usefulness that solve a problem you didn’t even know you had, just as you realize you have it.

That’s cool.

Oh – and last but most certainly not least: An application that works consistently enough like the old version of the same application so users don’t have to relearn everything they’ve learned to be as efficient with the new version as they were with the old.

THAT’s cool.

I don’t want shiny sparkly crap in my software.  I don’t want context sensitive menus where I have to know what I’m looking for in order to find it (hint: the whole ribbon thing did nothing to increase productivity for a long honking time.)

And there you go.

Software should be written for the user, and with the user in mind.  Anything that gets in the way of that, no matter how glitzy, no matter how sparkly and shiny – misses the point altogether.

—–

…and there is a post script to this story…

Last year, my mom was working on her Christmas letter – in Microsoft Word, and she wanted to send it to someone to do some proof reading.

Before, she’d had to go through a web interface on her computer to get to email – and sending the text of a document involved copying all the text in the document, opening the web email interface, creating a new outgoing mail, putting in the address, tabbing a couple of times, typing in the subject, one more tab, then a paste.  It worked, but it was pretty convoluted.

Then I got Outlook Express configured on her box, so now when she wants to send a document, it’s a matter of going up to the file menu in Word, choosing send, typing in the name, and then hitting the send button.

The first time she did that she was floored.  “That’s so EASY!” and then, remembering this story, she changed that just a bit…

“That’s so COOOOL!!!”

And she’s been rubbing it in ever since.

So even though the people who made Outlook Express 6 work with Word 2003 on Windows XP are probably long moved on from those projects, a note of thanks to the architects, devs, testers, PM’s, and managers who shepherded those things all the way through to RTM:  Ya done good.

I knew that the whole thing about our lives as computer professionals involves ones and zeroes.  So I thought, “Hmmm… I wonder what this code would look like if I translated it into binary? And how easy it would be to debug?”

So I did that, and was overloaded with a bunch of binary, so then took a simple backup script and translated that.  The result, below, is what the computer sees when it executes this little backup script.

Note: what’s below, translated from t-SQL into binary, is code that worked.  (yes, you’ll have to scroll for a bit, but there’s some human readable stuff in the middle, and some more at the end…)

01110011 01100101 01101100 01100101 01100011 01110100 00100000 01000000 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00001101 00001010 01100100 01100101 01100011 01101100 01100001 01110010 01100101 00100000 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00001001 00001001 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110011 00110000 00101001 00001101 00001010 01100100 01100101 01100011 01101100 01100001 01110010 01100101 00100000 01000000 01101001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01101110 01100001 01101101 01100101 00001001 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110011 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01110010 01100101 01110000 01101111 01110010 01110100 01100101 01111000 01100101 01100011 01110101 01110100 01100101 00100000 00100000 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110001 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00100000 00100000 00100000 00100000 00001001 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110001 00110000 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01100010 01100001 01100011 01101011 01110101 01110000 01101110 01100001 01101101 01100101 00100000 00100000 00100000 00100000 00100000 01010110 01000001 01010010 01000011 01001000 01000001 01010010 00100000 00101000 00110101 00110000 00101001 00100000 00100000 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01100011 01101101 01100100 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00001001 01010110 01000001 01010010 01000011 01001000 01000001 01010010 00101000 00110100 00110000 00110000 00110000 00101001 00100000 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01110011 01101111 01110101 01110010 01100011 01100101 01110000 01100001 01110100 01101000 00100000 00100000 00100000 00100000 00100000 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110010 00110101 00110000 00101001 00100000 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01110100 01100001 01110010 01100111 01100101 01110100 01110000 01100001 01110100 01101000 00100000 00100000 00100000 00100000 00100000 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110010 00110101 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01101110 01101111 01110111 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00001001 01000011 01001000 01000001 01010010 00101000 00110001 00110100 00101001 00100000 00100000 00100000 00001101 00001010 00001101 00001010 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00100000 00111101 00100000 00101000 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01110110 01100001 01101100 01110101 01100101 00100000 01100110 01110010 01101111 01101101 00100000 01100100 01100010 01100001 00101110 01100100 01100010 01101111 00101110 01010011 01100101 01110010 01110110 01100101 01110010 01010000 01110010 01101111 01110000 01100101 01110010 01110100 01101001 01100101 01110011 00100000 01110111 01101000 01100101 01110010 01100101 00100000 01100100 01100001 01110100 01100001 00100000 00111101 00100000 00100111 01010011 01100101 01110010 01110110 01100101 01110010 01001110 01100001 01101101 01100101 00100111 00101001 00001101 00001010 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01000000 01101001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01101110 01100001 01101101 01100101 00100000 00111101 00101000 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01110110 01100001 01101100 01110101 01100101 00100000 01100110 01110010 01101111 01101101 00100000 01100100 01100010 01100001 00101110 01100100 01100010 01101111 00101110 01010011 01100101 01110010 01110110 01100101 01110010 01010000 01110010 01101111 01110000 01100101 01110010 01110100 01101001 01100101 01110011 00100000 01110111 01101000 01100101 01110010 01100101 00100000 01100100 01100001 01110100 01100001 00100000 00111101 00100000 00100111 01001001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01001110 01100001 01101101 01100101 00100111 00101001 00001101 00001010 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 00100000 01000000 01110010 01100101 01110000 01101111 01110010 01110100 01100101 01111000 01100101 01100011 01110101 01110100 01100101 00100000 00100000 00111101 00100000 00100111 01000101 01011000 01000101 01000011 01110101 01110100 01100101 00100111 00100000 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00100000 00100000 00100000 00100000 00001001 00111101 00100000 00100111 01101101 01100001 01110011 01110100 01100101 01110010 00100111 00100000 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 00100000 01000000 01110011 01101111 01110101 01110010 01100011 01100101 01110000 01100001 01110100 01101000 00100000 00100000 00100000 00100000 00100000 00111101 00100000 00100111 01011100 01011100 00100111 00101011 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00101011 00100111 01011100 00100111 00101011 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00101011 00100111 01011111 00100111 00101011 01000000 01101001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01101110 01100001 01101101 01100101 00101011 00100111 01011111 01100010 01100001 01100011 01101011 01110101 01110000 00100111 00001101 00001010 01010011 01000101 01010100 00001001 00001001 01000000 01101110 01101111 01110111 00001001 00001001 00001001 00111101 00100000 01010010 01000101 01010000 01001100 01000001 01000011 01000101 00101000 01010010 01000101 01010000 01001100 01000001 01000011 01000101 00101000 01010010 01000101 01010000 01001100 01000001 01000011 01000101 00101000 01000011 01001111 01001110 01010110 01000101 01010010 01010100 00101000 01010110 01000001 01010010 01000011 01001000 01000001 01010010 00101000 00110101 00110000 00101001 00101100 00100000 01000111 01000101 01010100 01000100 01000001 01010100 01000101 00101000 00101001 00101100 00100000 00110001 00110010 00110000 00101001 00101100 00100000 00100111 00101101 00100111 00101100 00100000 00100111 00100111 00101001 00101100 00100000 00100111 00100000 00100111 00101100 00100000 00100111 00100111 00101001 00101100 00100000 00100111 00111010 00100111 00101100 00100000 00100111 00100111 00101001 00100000 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00001001 01000000 01100010 01100001 01100011 01101011 01110101 01110000 01001110 01100001 01101101 01100101 00001001 00001001 00111101 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00101011 00100000 00100111 01011111 01100100 01100010 01011111 00100111 00100000 00101011 00100000 01000000 01101110 01101111 01110111 00100000 00100000 00001101 00001010 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 01000000 01100011 01101101 01100100 00100000 00111101 00001001 00100111 01100010 01100001 01100011 01101011 01110101 01110000 00100000 01100100 01100001 01110100 01100001 01100010 01100001 01110011 01100101 00100000 00100111 00100000 00101011 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00101011 00100000 00001101 00001010 00001001 00001001 00001001 00001001 00100111 00100000 01110100 01101111 00100000 01100100 01101001 01110011 01101011 00100000 00111101 00100000 00100111 00100111 00100111 00100000 00101011 00100000 01000000 01110011 01101111 01110101 01110010 01100011 01100101 01110000 01100001 01110100 01101000 00100000 00101011 00100000 00100111 01011100 00100111 00101011 00100000 01000000 01100010 01100001 01100011 01101011 01110101 01110000 01101110 01100001 01101101 01100101 00100000 00101011 00100111 00101110 01100010 01100001 01101011 00100111 00100111 00100111 00100000 00101011 00100000 00001101 00001010 00001001 00001001 00001001 00001001 00100111 00100000 01110111 01101001 01110100 01101000 00100000 01110011 01110100 01100001 01110100 01110011 00100111 00100000 00001101 00001010 00001101 00001010 00001101 00001010 01010000 01010010 01001001 01001110 01010100 00100000 00100000 01000000 01100011 01101101 01100100 00100000 00001101 00001010 00001101 00001010 01001001 01000110 00100000 00100000 00100000 00100000 00100000 01000000 01110010 01100101 01110000 01101111 01110010 01110100 01100101 01111000 01100101 01100011 01110101 01110100 01100101 00100000 00111101 00100000 00100111 01000101 01011000 01000101 01000011 01110101 01110100 01100101 00100111 00100000 00001101 00001010 00100000 00100000 00100000 01000010 01000101 01000111 01001001 01001110 00100000 00001101 00001010 00100000 00100000 00100000 00100000 00100000 00100000 00100000 01000101 01011000 01000101 01000011 00100000 00101000 01000000 01100011 01101101 01100100 00101001 00001101 00001010 00100000 00100000 00100000 01000101 01001110 01000100 00100000 00001101 00001010 00001101 00001010

And this piece of code won’t work…

01110011 01100101 01101100 01100101 01100011 01110100 00100000 01000000 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00001101 00001010 01100100 01100101 01100011 01101100 01100001 01110010 01100101 00100000 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00001001 00001001 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110011 00110000 00101001 00001101 00001010 01100100 01100101 01100011 01101100 01100001 01110010 01100101 00100000 01000000 01101001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01101110 01100001 01101101 01100101 00001001 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110011 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01110010 01100101 01110000 01101111 01110010 01110100 01100101 01111000 01100101 01100011 01110101 01110100 01100101 00100000 00100000 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110001 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00100000 00100000 00100000 00100000 00001001 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110001 00110000 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01100010 01100001 01100011 01101011 01110101 01110000 01101110 01100001 01101101 01100101 00100000 00100000 00100000 00100000 00100000 01010110 01000001 01010010 01000011 01001000 01000001 01010010 00100000 00101000 00110101 00110000 00101001 00100000 00100000 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01100011 01101101 01100100 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00001001 01010110 01000001 01010010 01000011 01001000 01000001 01010010 00101000 00110100 00110000 00110000 00110000 00101001 00100000 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01110011 01101111 01110101 01110010 01100011 01100101 01110000 01100001 01110100 01101000 00100000 00100000 00100000 00100000 00100000 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110010 00110101 00110000 00101001 00100000 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01110100 01100001 01110010 01100111 01100101 01110100 01110000 01100001 01110100 01101000 00100000 00100000 00100000 00100000 00100000 01110110 01100001 01110010 01100011 01101000 01100001 01110010 00101000 00110010 00110101 00110000 00101001 00001101 00001010 01000100 01000101 01000011 01001100 01000001 01010010 01000101 00100000 01000000 01101110 01101111 01110111 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00100000 00001001 01000011 01001000 01000001 01010010 00101000 00110001 00110100 00101001 00100000 00100000 00100000 00001101 00001010 00001101 00001010 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00100000 00111101 00100000 00101000 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01110110 01100001 01101100 01110101 01100101 00100000 01100110 01110010 01101111 01101101 00100000 01100100 01100010 01100001 00101110 01100100 01100010 01101111 00101110 01010011 01100101 01110010 01110110 01100101 01110010 01010000 01110010 01101111 01110000 01100101 01110010 01110100 01101001 01100101 01110011 00100000 01110111 01101000 01100101 01110010 01100101 00100000 01100100 01100001 01110100 01100001 00100000 00111101 00100000 00100111 01010011 01100101 01110010 01110110 01100101 01110010 01001110 01100001 01101101 01100101 00100111 00101001 00001101 00001010 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01000000 01101001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01101110 01100001 01101101 01100101 00100000 00111101 00101000 01110011 01100101 01101100 01100101 01100011 01110100 00100000 01110110 01100001 01101100 01110101 01100101 00100000 01100110 01110010 01101111 01101101 00100000 01100100 01100010 01100001 00101110 01100100 01100010 01101111 00101110 01010011 01100101 01110010 01110110 01100101 01110010 01010000 01110010 01101111 01110000 01100101 01110010 01110100 01101001 01100101 01110011 00100000 01110111 01101000 01100101 01110010 01100101 00100000 01100100 01100001 01110100 01100001 00100000 00111101 00100000 00100111 01001001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01001110 01100001 01101101 01100101 00100111 00101001 00001101 00001010 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 00100000 01000000 01110010 01100101 01110000 01101111 01110010 01110100 01100101 01111000 01100101 01100011 01110101 01110100 01100101 00100000 00100000 00111101 00100000 00100111 01000101 01011000 01000101 01000011 01110101 01110100 01100101 00100111 00100000 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00100000 00100000 00100000 00100000 00001001 00111101 00100000 00100111 01101101 01100001 01110011 01110100 01100101 01110010 00100111 00100000 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 00100000 01000000 01110011 01101111 01110101 01110010 01100011 01100101 01110000 01100001 01110100 01101000 00100000 00100000 00100000 00100000 00100000 00111101 00100000 00100111 01011100 01011100 00100111 00101011 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00101011 00100111 01011100 00100111 00101011 01000000 01110011 01100101 01110010 01110110 01100101 01110010 01101110 01100001 01101101 01100101 00101011 00100111 01011111 00100111 00101011 01000000 01101001 01101110 01110011 01110100 01100001 01101110 01100011 01100101 01101110 01100001 01101101 01100101 00101011 00100111 01011111 01100010 01100001 01100011 01101011 01110101 01110000 00100111 00001101 00001010 01010011 01000101 01010100 00001001 00001001 01000000 01101110 01101111 01110111 00001001 00001001 00001001 00111101 00100000 01010010 01000101 01010000 01001100 01000001 01000011 01000101 00101000 01010010 01000101 01010000 01001100 01000001 01000011 01000101 00101000 01010010 01000101 01010000 01001100 01000001 01000011 01000101 00101000 01000011 01001111 01001110 01010110 01000101 01010010 01010100 00101000 01010110 01000001 01010010 01000011 01001000 01000001 01010010 00101000 00110101 00110000 00101001 00101100 00100000 01000111 01000101 01010100 01000100 01000001 01010100 01000101 00101000 00101001 00101100 00100000 00110001 00110010 00110000 00101001 00101100 00100000 00100111 00101101 00100111 00101100 00100000 00100111 00100111 00101001 00101100 00100000 00100111 00100000 00100111 00101100 00100000 00100111 00100111 00101001 00101100 00100000 00100111 00111010 00100111 00101100 00100000 00100111 00100111 00101001 00100000 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00001001 01000000 01100010 01100001 01100011 01101011 01110101 01110000 01001110 01100001 01101101 01100101 00001001 00001001 00111101 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00101011 00100000 00100111 01011111 01100100 01100010 01011111 00100111 00100000 00101011 00100000 01000000 01101110 01101111 01110111 00100000 00100000 00001101 00001010 00001101 00001010 01010011 01000101 01001100 01000101 01000011 01010100 00100000 01000000 01100011 01101101 01100100 00100000 00111101 00001001 00100111 01100010 01100001 01100011 01101011 01110101 01110000 00100000 01100100 01100001 01110100 01100001 01100010 01100001 01110011 01100101 00100000 00100111 00100000 00101011 00100000 01000000 01100100 01100010 01101110 01100001 01101101 01100101 00100000 00101011 00100000 00001101 00001010 00001001 00001001 00001001 00001001 00100111 00100000 01110100 01101111 00100000 01100100 01101001 01110011 01101011 00100000 00111101 00100000 00100111 00100111 00100000 00101011 00100000 01000000 01110011 01101111 01110101 01110010 01100011 01100101 01110000 01100001 01110100 01101000 00100000 00101011 00100000 00100111 01011100 00100111 00101011 00100000 01000000 01100010 01100001 01100011 01101011 01110101 01110000 01101110 01100001 01101101 01100101 00100000 00101011 00100111 00101110 01100010 01100001 01101011 00100111 00100111 00100111 00100000 00101011 00100000 00001101 00001010 00001001 00001001 00001001 00001001 00100111 00100000 01110111 01101001 01110100 01101000 00100000 01110011 01110100 01100001 01110100 01110011 00100111 00100000 00001101 00001010 00001101 00001010 00001101 00001010 01010000 01010010 01001001 01001110 01010100 00100000 00100000 01000000 01100011 01101101 01100100 00100000 00001101 00001010 00001101 00001010 01001001 01000110 00100000 00100000 00100000 00100000 00100000 01000000 01110010 01100101 01110000 01101111 01110010 01110100 01100101 01111000 01100101 01100011 01110101 01110100 01100101 00100000 00111101 00100000 00100111 01000101 01011000 01000101 01000011 01110101 01110100 01100101 00100111 00100000 00001101 00001010 00100000 00100000 00100000 01000010 01000101 01000111 01001001 01001110 00100000 00001101 00001010 00100000 00100000 00100000 00100000 00100000 00100000 00100000 01000101 01011000 01000101 01000011 00100000 00101000 01000000 01100011 01101101 01100100 00101001 00001101 00001010 00100000 00100000 00100000 01000101 01001110 01000100 00100000 00001101 00001010 00001101 00001010

Why won’t it work?

Because it’s missing an apostrophe.

So if that’s a bunch of ones and zeroes that have to be in the right order just to back up a database – how many ones and zeroes need to be in the right order to keep our databases and systems running right?  I mean really, if you think of your T-SQL code, then the SQL executables and the binaries there, and the operating system it rides on, and if your systems are clustered and virtual, you’ve got your clustering layer, and your virtualization layer, and all the software and firmware of your SAN, not to mention the app that might ride on top of your code.  It actually gets pretty mind boggling that it all works at all, and makes it that much more important that the code we as SQL folks write, is flawless.

Given that we often think of the big, complex things about SQL, I thought I’d just bring a small bit to your attention.

Take care – be safe out there.

Oh – By the way… the code is below:

select  @@servername

declare @servername     varchar(30)

declare @instancename   varchar(30)

DECLARE @reportexecute  varchar(10)

DECLARE @dbname         varchar(100)

DECLARE @backupname     VARCHAR (50)

DECLARE @cmd            VARCHAR(4000)

DECLARE @sourcepath     varchar(250)

DECLARE @targetpath     varchar(250)

DECLARE @now            CHAR(14)

select @servername = (select value from dba.dbo.ServerProperties where data = ‘ServerName’)

select @instancename =(select value from dba.dbo.ServerProperties where data = ‘InstanceName’)

SELECT  @reportexecute  = ‘EXECute’

SELECT  @dbname         = ‘master’

–Note: I’ve got a set of shares set up on all my servers, so tend to write backup scripts as below.

–You may need to change that to a path that’s valid on your system to get this to work.

SELECT  @sourcepath     =

‘\\’+@servername+’\'+@servername+’_'+@instancename

+ ‘_backup’

SET     @now                  = REPLACE(REPLACE(REPLACE(CONVERT(VARCHAR(50),

GETDATE(), 120), ‘-’, ”), ‘ ‘, ”), ‘:’, ”)

SELECT  @backupName     = @dbname + ‘_db_’ + @now

SELECT @cmd             =     ‘backup database ‘ + @dbname

+ ‘ to disk = ”’ + @sourcepath + ‘\’+ @backupname

+ ‘.bak”’ + ‘ with stats’

PRINT  @cmd

IF     @reportexecute = ‘EXECute’

BEGIN

EXEC (@cmd)

END

So I’ll tell you about my experience – might not work for you – but it did for me, so I thought I’d share the experience.

It all started with a patch cycle, a server that wouldn’t come online, and we enter our little story with me staring at this entry in the SQL error log:

Cannot recover the master database. SQL Server is unable to run. Restore master from a full backup, repair it, or rebuild it. For more information about how to rebuild the master database, see SQL Server Books Online

Oh good.

Now I’ve had to restore a master database before.  It’s not fun.  By the time you get to the point of actually having to do this, chances are you’ve done a bunch of troubleshooting, you’re already frazzled, the pressure is on, and clear thinking is both critically important, which, because of the pressure, and as elusive as a Sasquatch in Singapore..  Rebuilding a master database was just not something I wanted to do because of what I’d lose. Restoring it seemed like a better idea – so I did some thinking, and remembered something I’d learned in a PSS call a long time ago, in a galaxy far, far away…

It involved restoring the master database, but doing it in a way that didn’t involve using anything on the command line – it was just straight SQL.

I’m sure you’re thinking, “But… SQL won’t start!”

Yup…

You are correct, young grasshopper, and have been listening along well…

But let’s not be afraid to think outside the box, shall we?

This was a clustered server, and it would start, but wouldn’t stay running no matter what I did. Looking at that error log gave me an idea, and the good thing was that I did have backups.

So here – I’ll give you the big picture in a nutshell, then we’ll go to details:

• The thing that SQL wants when it fires up is an MDF and LDF file from the master database.
• Given that, somehow, I needed to get not only an MDF and LDF file for the master database, but one from my toasted server.
• Once I could get them to that server, it ought to start up, because we know the backup’s good, right?

So let’s give this a shot.

Since I had the backups, I restored the latest one *as a user database* onto a test box – giving it a different name and putting the files in a location not standard for that box (that way the test box wouldn’t be confused by me trying to put two master.MDF files in the same directory).

I made sure the Test server was the same release/patch level/build number as the production server so I wouldn’t run into any inadvertent upgrades I wasn’t planning on doing.

So on my Test server (I wasn’t going to play with production, production was broke, I didn’t want to break it more) –

I created a folder with a name I could remember in a location I wouldn’t forget

For example, we’ll make a directory called C:\EMERGENCY_MASTER_BACKUP

I then copied the production backup into that directory, just to keep everything all in one place.

Now, remember when I was talking about restoring the master database as a user database? This is where this happened.  I did a restore command on the test server – but did it a little differently, just so I could get those MDF and LDF files to exist, and to have them to use back on my production server.

Given the directory we made up above, I wrote a restore command something like this:

Restore database masterback

From disk = ‘c:\Emergency_master_backup\<whatever the name of the backup was>

With

Move ‘master’ to ‘c:\emergency_master_backup\master.MDF’,

Move ‘mast_log’ to ‘c:\emergency_master_backup\mastllog.LDF’

Note: this is a very standard restore command, only you’re using a master database backup, and you’re fooling SQL into thinking it’s a user database by changing the name.  That’s it.

Examples of this code and further information on restores can be found here: http://msdn.microsoft.com/en-us/library/ms186858.aspx

I hit control E, and in a few seconds, had a user database sitting there on my box, looking for all the world like a master database, except it was a user database.

So what I wanted, remember, was the MDF and LDF files, and I couldn’t use them if SQL had its hooks in them, so I detached the database.  That way I could copy them back over to my production box.

With great fanfare, I copied them over to the broken production server – and remember? All SQL wants is an MDF and an LDF file it can read.  Given that those were the only two files that were screwed up, I renamed the existing ones on the server so SQL wouldn’t find them, (I think I called them *.MDFold  – and *.LDFold – just so SQL didn’t recognize them) and then copied the ones I’d just detached from the test server into the same directory the screwed up files were in on the production server.

Understand, SQL was very stopped at this point.

What I’d done is taken the broken MDF and LDF files for the master database and replaced them with functional ones.

Next bit was to go into cluster administrator and see if I could start SQL.

I right clicked on the instance name, selected ‘Bring Online’ – and to my great relief, it fired up in about a second.

The next day I had to interview someone, and presented him with this situation.  He gave me the absolute textbook answers – I was truly impressed with the depth of his knowledge, and feel that the textbook depth of his answers will be very, very useful when the times comes, but the experience of a few (in this case, Microsoft sanctioned from that PSS case those many years ago) shortcuts learned over the years helped me get the server up and running more quickly than it would have taken for me to dust off all the command line master database recovery commands that I’m not nearly as familiar with.

That sounds nice and sophisticated.  What really happened was that I worked in a group with a bunch of little old ladies –meant in the dearest sense you could mean it – they were little, and old, and ladies.  Imagine working with your mom or grandma to get the picture.  They made calls to new members in the various regions to inform them of the possibilities they could expect with their new membership.  My job was to automate the data gathering of the department.  Each telephone call was logged, categorized, and eventually summarized so the region could be billed for the work done on their behalf.

How this was done was simple: Paper, pencil, and a bunch of little hash marks: IIIII IIIII IIIII,

My job – summarize it so those hash marks could be turned into money at the end of the quarter.

I sat there with a solar powered calculator adding hash marks for weeks every quarter while a $2000.00 computer sitting on my desk burned electrons.  So automation became necessary, but automating it so a bunch of little old ladies could use it – correction – would use it – was key.

I’d been told that for this data gathering project, I would not be allowed to use a database, I would have to use Microsoft’s Excel.  And so, technically, I had to make Excel look and act like a database, but more importantly, I had to get these little old ladies (who can be mighty stubborn, I might add) to go from things they could see and feel (pencil and paper) to things they couldn’t (electrons).

One of the little old ladies was named Georgiana.  She had been diagnosed with ADD, and was quite aware of it, so she worked hard, with stacks of post-it notes all over to help keep herself on track.  She also was an absolute delight to work with, and would tell me any time some code I wrote didn’t make sense.  Conversely, if it did make sense, and she understood it, she would let me know – and then I knew everyone else would understand it as well.

So Georgiana became my canary in the coal mine.  She would not only tell me when she didn’t understand how some functionality was supposed to work, she would also tell me when the others had trouble.

And as a result, that trouble, whatever it was, would get fixed.  In human terms, they’d understand it better.  In business terms, their productivity would go up.  In human terms, they’d have less frustration.  In business terms, there’d be fewer impediments to them doing their jobs.

All because the code was written with the customer in mind.

I wrote thousands of lines of code for that project.  It eventually became a distributed data repository, on two separate, totally incompatible networks, that could quite literally only communicate via email, so the calculations happened via Excel macros, daily reporting happened via distributed Excel, Outlook macros and Novell Groupwise automation, and summarization and reporting at the end of the quarter was done in Excel and Word.  This took the generation of the report down from weeks to two hours, a major accomplishment – but it became very clear to me that no matter how wonderful, how exciting, how shiny, sparkly or technically brilliant the code was, if I didn’t listen to my customers – if my code didn’t solve the problems they were facing on a daily basis, then they wouldn’t use it.  If it didn’t do what the customer wanted, then all the effort I put into it was a complete waste of time.

And over time, I realized that more and more, the code I wrote was written with a little old lady in mind.  It’s been 15 years now, but in every line of code I write now is a little bit written for my friend Georgiana.

DATABASES AND FRAT HOUSES

Okay folks, so here’s a basic example of why you want to have your database the right size to start with, and why setting things to “autogrow” and “autoshrink” is a bad idea.

Ready?

Let’s say you go to – oh, say, the Local University, and you live in a frat house with 39 of your closest friends and associates.

Let’s also say that this frat house has parties on a rather regular basis, like, every Friday and Saturday night, and about 100 people show up.

Now if the house is big enough, you set up tables, snacks, “beverages”, and music, and people have a good time, in addition to getting plastered, puking on the lawn and so on – (but that’s outside the house, so we’ll deal with puking on the lawn in another issue.)

So far so good, right?  People have places to congregate, dance, chat, do all that other stuff that happens at frat parties, and so on.  No problem… The house is big enough, might be a little crowded sometimes, might be full of hot, sweaty bodies during the party, but basically, it’s a party, everyone’s having a good time, and no one will remember much of it on Saturday morning.

Except for those guys lying on the front lawn, but again, that’s another story.

This is what happens if you make your database big enough to handle the data you’re planning on putting into it.  Your application has room to do its thing, SQL has room to function when weekly maintenance is needed, and it can grow, make temp tables, and make calculations.  It’s got room to fold, spindle, and mutilate the data all it wants, and it will do so happily.

Now let’s assume, for a moment, that for some reason – it might even be a good one, you didn’t set it up that way.  You want your database to be small, and full, and you don’t quite understand that a database can be very large (think big Frat House) yet be very empty (think same Frat house on a Wednesday morning when everyone’s supposed to be in class).

So… you wanted it to be small, to “save space”.  Let’s see what happens if we do that to our frat boys.

It’s Monday, you’ve got a nice little frat house with room for 40 of you in there, and everything’s cozy, but you decide to have a party to celebrate the upcoming weekend.  Well, come Friday night, people start coming in the door, and pretty soon, you know what? You’ve got a bunch of hot, sweaty bodies in the house, and there really isn’t enoughroom to do much of anything… You can’t dance, you can’t even get to the “beverages”.

What to do? Well, you decide to assign 10 of the young guys to make the place bigger. They run off to Lowe’s with the frat checkbook and wide eyes and they get some building materials to remodel the place and make it bigger.  At first, 10 guys being gone gives you a little more room, but then they come back and start working. Soon there’s sawdust and sheetrock dust flying everywhere.  The plaster dust starts caking on the sweat, and it looks a little weird. They don’t move nearly as well as they could – in fact, they kind of start slowing down a bit.

It gets, in a word, weird.

So, let’s get back to the party. Now there are  so many people showing up (the line goes out to the street) that the guys who are remodeling are told to make more room. So, they take over more and more rooms in the house. Soon, even the bathroom has been remodeled to the point that there’s nothing in it so that people attending the party can fit in there.  The guys doing the remodeling shut off the plumbing, take out the toilet, sink and shower. All you see is the floor, walls, and people in this room that used to be the bathroom because everything else has been removed to make room for the crowd. Problem is,  when the bathroom is needed, there is nowhere to “go”. So, suddenly someone from the frat house is  calling for Porta Potties to be brought and put in the yard so people can “do” what they need to “do”.

Meanwhile, your remodeling crew has been so busy, they are asking for help, so 10 frat brothers go outside to help to put up the Porta-Potties.  (there’s a lot of Porta-Potties, play along with me here) Problem is, someone discovers that in addition to  having no bathroom now, the guys doing the remodeling have taken out the kitchen, so someone needs to call a caterer to help with the food because there’s   nowhere to prepare it anymore.  They set up the food the yard, too – opposite the Porta-Potties.

Eventually someone gets the bright idea to borrow a room in the neighboring frat house and part of the party moves over there. Soon things start spiraling out of control next door while other things in the original house are grinding to a halt.  The cops are called in at 3:00 AM and need to intervene in both houses.

It gets ugly.

Saturday morning comes around and the University decides that all the remnants of the party (beverage containers, Porta-Potties, etc) need to be removed. The city gets wind of what happened, and they figure out that  all this remodeling was done without a permit, and order it to be undone.

So now you have a mess. Guys who aren’t anywhere near awake are trying to reinstall plumbing, rip out sheetrock, and clean up after themselves – and they’ve got better things to do – like sleep – or study, or something…The next week, they decide to have another party and the same thing happens again… House is too small.  Remodeling happens because of the party.  Next morning, the remodeling is ripped out. .  –After awhile, you’ve got a bunch of guys who are pretty thrashed, and who aren’t really good for anything, whether it’s studies, frat stuff, or any other college event.  You have a frat house that’s in shambles from being rebuilt so many times, the front yard is now mush.  People can’t get into the house because of the mud in the front yard, the leftover construction materials scattered all over the place, and so on.  The neighbors are more than a little peeved, and the problem list goes on.

Get the idea?

If you make your database too small to start with – and you need to do something like rebuild the indexes on a weekly basis (Friday night party) – it’s going to grow.  Log file’s going to grow, likely the database file is going to grow, and SQL is going to have to spend resources doing the actual growing.  When it’s doing that, it’s putting other stuff on hold, and if you have it set to auto-grow by percent – that gets even worse.  You start off, with, say, a 1 gig database.  You want it growing by 10%.  So when it fills up, next time it will grow to 1.1 gig database.  No problem.  When this thing grows to a 100 gig database, when it decides to grow, it’s going to have to grow by 10% of 100 gigs, as in 10 gigs.  If your file system is fragmented, SQL is going to have to find 10 gigs worth of space scattered about your drive, and grow into that.

(this is our frat boys going into the neighbors house, putting the Porta-Potties and caterer out in the yard)

If that file system is fragmented – now your SQL file is also fragmented because it grew into a bad situation.  Now any index rebuilding/defragging you do may help a little bit from the SQL end, but the file system is still going to have to write/log activity to the hard drive, and if your data and/or log files are scattered all over the drive, your drive head’s going to be getting frequent flyer miles flying back and forth just trying to read a single database file.

Performance suffers because all that time spent by the drive head flying back and forth takes time.  The disk subsystem has to wait to do the read and/or write till the disk comes around again if the drive head wasn’t in the right spot for that initial read.

So… you end up with fragmented indexes within SQL – well, fragmented everything within SQL.  You end up with the SQL files themselves being fragmented on the file system level – and you have to start there.  (think all sorts of bits and pieces of SQL files strewn all over the drive like – ‘beverage’ containers)

So…

Find out how big to make your database.  Figure out what level of growth you’re going to have.  Try to have it set to last as long as you can, a year is good.  Once you’ve got that done- the drive will look very full (think huge frat house) but the database will have room to grow (think huge frat house with just a few guys in it – you’ll be able to have huge parties in there (think rebuilding indexes, doing large logged operations you might want to undo, etc.) without waking up the neighbors, without remodeling anything, and without having to wake up cops, the NOC or DBA’s in the middle of the night.

Fix that.  Then when you’re done, get your SQL indexes taken care of.

By the time you’re done, your performance will improve tremendously as SQL knows where things are, the OS knows where to look for the things SQL wants it to find, – and you won’t have to deal with any drunken frat boys messing with your SQL server.