Writing a blob object to the database
by Jakub Narębski, Rasmus Voss, Aske Olsson, Ferdinando Santacroce
Git: Mastering Version Control
- Git: Mastering Version Control
- Table of Contents
- Git: Mastering Version Control
- Git: Mastering Version Control
- Credits
- Preface
- I. Module 1
- 1. Getting Started with Git
- 2. Git Fundamentals – Working Locally
- 3. Git Fundamentals – Working Remotely
- 4. Git Fundamentals – Niche Concepts, Configurations, and Commands
- Dissecting the Git configuration
- Configuration architecture
- Configuration levels
- Listing configurations
- Editing configuration files manually
- Setting up other environment configurations
- Basic configurations
- 5. Obtaining the Most – Good Commits and Workflows
- The art of committing
- Adopting a workflow – a wise act
- Summary
- 6. Migrating to Git
- 7. Git Resources
- II. Module 2
- 1. Navigating Git
- 2. Configuration
- 3. Branching, Merging, and Options
- 4. Rebase Regularly and Interactively, and Other Use Cases
- 5. Storing Additional Information in Your Repository
- 6. Extracting Data from the Repository
- 7. Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts
- Introduction
- Using a branch description in the commit message
- Creating a dynamic commit message template
- Using external information in the commit message
- Preventing the push of specific commits
- Configuring and using Git aliases
- Configuring and using Git scripts
- Setting up and using a commit template
- 8. Recovering from Mistakes
- Introduction
- Undo – remove a commit completely
- Undo – remove a commit and retain the changes to files
- Undo – remove a commit and retain the changes in the staging area
- Undo – working with a dirty area
- Redo – recreate the latest commit with new changes
- Revert – undo the changes introduced by a commit
- Reverting a merge
- Viewing past Git actions with git reflog
- Finding lost changes with git fsck
- 9. Repository Maintenance
- Introduction
- Pruning remote branches
- Running garbage collection manually
- Turning off automatic garbage collection
- Splitting a repository
- Rewriting history – changing a single file
- Back up your repositories as mirror repositories
- A quick submodule how-to
- Subtree merging
- Submodule versus subtree merging
- 10. Patching and Offline Sharing
- 11. Git Plumbing and Attributes
- Introduction
- Displaying the repository information
- Displaying the tree information
- Displaying the file information
- Writing a blob object to the database
- Writing a tree object to the database
- Writing a commit object to the database
- Keyword expansion with attribute filters
- Metadata diff of binary files
- Storing binaries elsewhere
- Checking the attributes of a file
- Attributes to export an archive
- 12. Tips and Tricks
- III. Module 3
- 1. Git Basics in Practice
- An introduction to version control and Git
- Git by example
- Repository setup
- Creating a Git repository
- Cloning the repository and creating the first commit
- Publishing changes
- Examining history and viewing changes
- Renaming and moving files
- Updating your repository (with merge)
- Creating a tag
- Resolving a merge conflict
- Adding files in bulk and removing files
- Undoing changes to a file
- Creating a new branch
- Merging a branch (no conflicts)
- Undoing an unpublished merge
- Summary
- 2. Exploring Project History
- 3. Developing with Git
- 4. Managing Your Worktree
- Ignoring files
- File attributes
- Fixing mistakes with the reset command
- Stashing away your changes
- Managing worktrees and the staging area
- Multiple working directories
- Summary
- 5. Collaborative Development with Git
- 6. Advanced Branching Techniques
- Types and purposes of branches
- Branching workflows and release engineering
- Interacting with branches in remote repositories
- Summary
- 7. Merging Changes Together
- 8. Keeping History Clean
- An introduction to Git internals
- Rewriting history
- Amending history without rewriting
- Summary
- 9. Managing Subprojects – Building a Living Framework
- Managing library and framework dependencies
- Managing large Git repositories
- Summary
- 10. Customizing and Extending Git
- 11. Git Administration
- 12. Git Best Practices
- 1. Git Basics in Practice
- A. Bibliography
- Index
- Configuration architecture
- Dissecting the Git configuration
In this example, we'll see how we can use plumbing commands to add blob objects to the database. This is, of course, used internally by the git add command; however, this can also be useful if you, for example, need to add the public part of your GPG key to the Git repository so that signed tags can be verified. You can then, after you've added the key, tag the blob ID so that the other committers can find it.
We'll create and use a new repository for this example and the next couple of examples. Let's create a new repository in the myplumbing folder:
$ git init myplumbing Initialized empty Git repository in /path/to/myplumbing/.git/ $ cd myplumbing $ git status On branch master Initial commit nothing to commit (create/copy files and use "git add" to track)
Git uses the hash-object plumbing command to write objects to its database. We can use it to update the database with the content of files, or pass the content directly on stdin. First, let's just see what is currently stored in the database (.git/objects) using the following command:
$ find .git/objects .git/objects .git/objects/info .git/objects/pack $ find .git/objects -type f
The database is empty as expected when we have just created the repository. Now, we can write an object to the database:
echo 'This is the content of my file' | git hash-object -w --stdin 70bacd9f51c26d602f474bbdc9f60644aa449e97
We can also try to use the hash-object command on a regular file:
$ echo 'This content is good' > mytest.txt $ git hash-object -w mytest.txt 926e8ffd3258ed6edd1e254438f02fd24e417acc
We can update the file and write the new content to the database:
$ echo 'This content is better' > mytest.txt $ git hash-object -w mytest.txt 6b3da706d14c3820597ec7109f163bc144dcbb22
The hash-object function will create a SHA-1 hash of the input given and if the -w switch is used, write it to the database. The command defaults to blob objects. We can investigate the contents of the database using the following command:
find .git/objects -type f .git/objects/6b/3da706d14c3820597ec7109f163bc144dcbb22 .git/objects/70/bacd9f51c26d602f474bbdc9f60644aa449e97 .git/objects/92/6e8ffd3258ed6edd1e254438f02fd24e417acc
We can see that the database contains the three objects we just created. As you can see, Git stores each object as a file where the two first digits of the SHA-1 are used as a subdirectory and the remaining 38 objects as the filename. To check the object in Git's database, we can use the cat-file command, just like we did in Chapter 1, Navigating Git. To check the contents of an object, we use the -p (pretty print) switch:
git cat-file -p 70bacd9f51c26d602f474bbdc9f60644aa449e97 This is the content of my file
We can also use the cat-file command to check the type of an object:
git cat-file -t 926e8ffd3258ed6edd1e254438f02fd24e417acc blob
-
No Comment