Tag: VCS

I recently had an issue in one of my Git repos, and decided to drop all my local changes and just pull down from the remote. This post looks at what I did.

Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBloggers. You can see all posts on Git as well.

A Bad State

The old cartoon looks like this:

In my case, I hadn’t done this. I didn’t have a fire, but I did leave the building.

Actually, what I’d done was made a few changes at home and hadn’t committed them. I was in between trips and in a hurry, and walked away. On the road, I made similar changes and did commit/push them. When I got home, I couldn’t git pull because of the conflict.

What’s worse, these were binary (Excel) files.

I could have tried to sort things out, but in this case, I knew the remote copy was likely more up to date in place and I could easily re-enter the data I’d saved but not committed.

The way to do this for me, for tracked changes, was git reset.

In my case, I wasn’t trying to reset to a particular commit, I just wanted to whack all changes I’d made. This was just one file for me, so I issued:

git reset -–hard

The -–hard discards changes to any tracked files. Changes to untracked files aren’t affected. I’ll write about that in another post.

This cleaned my local repo back to the last time I’d had a git pull. From here, I could just get changes from the remote and work on.

SQL New Blogger

This post took about 5 minutes, literally, to write. Some of that is I’m a good typist, some is this is a simple story. Any tech pro ought to be able to do this in 5 minutes as well. If not, learn to type or to structure a short story.

This shows a little tech knowledge, but also an explanation of a situation.

I wrote a post recently about pruning branches in git. That’s part of the job, but the other part is removing local branches. This post looks at one way to do that in a semi-manual fashion.

This could be automated, but it took seconds, so I did a quick manual thing. I’ll work on an automated way, but since I do this rarely, manual is fine for me.

Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBloggers. You can see all posts on Git as well.

Getting a List of Branches to Delete

In the last post I showed how to get a list of branches with dry run. This was the image I showed of branches. If I re-run that without the dry run, the branches are removed.

The output is similar, but either set of output works. Once we have a list of branches, what do we do? Let’s use SSMS to help.

SSMS Makes This Easy

If I highlight the results of my git prune, I can copy/paste those into SSMS. You can see below I’ve done this, and then held the ALT+Shift key to select a bunch of text in a box. This is all the text apart from the branch names.

Once I’ve done this, I can let go of those keys and type “git branch –d “, which will replace the text on every line. You can see this below.

This is a great technique, and while it works in VSCode and some other editors, I usually have SSMS open and it works very well here. I then select all this text, paste it back into the CMD window, accept the note that this is a multi-line paste, and all my deletes run.

Voila, all remote branches deleted are removed from my local git install. A few of these were already removed manually as I experimented.

SQL New Blogger

As I mentioned in the previous post, version control skills (especially git) are core for most technology pros. DBA, developers, sysadmin, anyone working with modern software development or administration likely needs to know about version control.

This post was about 10 minutes. You could write this in 15 and showcase your tech skills to a future employer.

As I’ve been working with SQL Saturday and managing changes to events, I’ve accumulated a lot of branches. Even though I’m a solo developer, I decided to use branches, as I expect others to share this load in the future. This post looks at how to start cleaning those up.

Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBloggers. You can see all posts on Git as well.

Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBloggers.

Finding Old Branches

When I ran the git branch command, I saw this. There are a lot of old branches in there.

I decided that I should reduce this number. After all, even removing stale branches means I have a lot of events in flight.

We use GitHub, and when I go on the site, I see lots of branches, some of which date back to last year. Those events are done, so I decided to delete some branches. In the image below, there are three branches. To the right, there are delete icons on the bottom two as I’ve already pressed the one to delete the remote branch on the top one.

Now, how do I delete the local branch? Let’s start by removing it.

Git Prune

There is a command to remove references to remote branches that are deleted: git prune. I deleted a few older branches, and then ran git prune for remotes, with the –dry-run option. This tells me what would happen. As you can see, a number of branch references would be deleted.

Nothing in here I’m worried about or that is active. I’ve deleted these on GitHub, so I’ll re-run the command without dry run. This removes the references.

Unfortunately, the local branches still exist. We don’t remove these, as it’s possible I have work on a local branch not sent to the remote, so doing this automatically, even if I do it, is dangerous.

I’ll do another post on removing the local branches.

Automating the Removal of Remote references

I might want to remove local references for branches that get deleted on the remote. This is useful if you delete branches on merge. I don’t in this case, as I’m often using the same branch for multiple changes for an event, rather than a new branch for every one.

One way to do this is to change the config with this:

git config remote.origin.prune true

This will then run the prune on each fetch or full. This helps keep things cleaner, though local branches still exist. However, if I commit to a local branch and push, I’ll get an error that I need to configure the upstream. That helps with me being aware of what’s active or not.

SQL New Blogger

Using version control is a core skill for anyone in technology. Even database people. You could write posts on how you use or learn about git (or something else) and showcase your skills.

This post took me about 15 minutes to write, even with screen shots.