Is it safe to shallow clone with –depth 1, create commits, and pull updates again?

by

Note that Git 1.9/2.0 (Q1 2014) has removed that limitation.
See commit 82fba2b, from Nguyễn Thái Ngọc Duy (pclouds):

Now that git supports data transfer from or to a shallow clone, these limitations are not true anymore.

The documentation now reads:

--depth <depth>::

Create a ‘shallow’ clone with a history truncated to the specified number of revisions.

That stems from commits like 0d7d285, f2c681c, and c29a7b8 which support clone, send-pack /receive-pack with/from shallow clones.
smart-http now supports shallow fetch/clone too.

All the details are in “shallow.c: the 8 steps to select new commits for .git/shallow“.

Update June 2015: Git 2.5 will even allow for fetching a single commit!
(Ultimate shallow case)

Update January 2016: Git 2.8 (Mach 2016) now documents officially the practice of getting a minimal history.
See commit 99487cf, commit 9cfde9e (30 Dec 2015), commit 9cfde9e (30 Dec 2015), commit bac5874 (29 Dec 2015), and commit 1de2e44 (28 Dec 2015) by Stephen P. Smith (“).
(Merged by Junio C Hamano — gitster — in commit 7e3e80a, 20 Jan 2016)

This is “Documentation/user-manual.txt”

A <<def_shallow_clone,shallow clone>> is created by specifying the git-clone --depth switch.
The depth can later be changed with the git-fetch --depth switch, or full history restored with --unshallow.

Merging inside a <<def_shallow_clone,shallow clone>> will work as long as a merge base is in the recent history.
Otherwise, it will be like merging unrelated histories and may have to result in huge conflicts.
This limitation may make such a repository unsuitable to be used in merge based workflows.

Update 2020:

  • git 2.11.1 introduced option git fetch --shallow-exclude= to prevent fetching all history
  • git 2.11.1 introduced option git fetch --shallow-since= to prevent fetching old commits.

For more on the shallow clone update process, see “How to update a git shallow clone?“.

As commented by Richard Michael:

to backfill history: git pull --unshallow

And Olle Härstedt adds in the comments:

To backfill part of the history: git fetch --depth=100.

More Related Contents:

  1. Git is really slow for 100,000 objects. Any fixes?
  2. Ways to improve git status performance
  3. Performance optimization strategies of last resort [closed]
  4. How to find the kth largest element in an unsorted array of length n in O(n)?
  5. HTTP vs HTTPS performance
  6. Is performance reduced when executing loops whose uop count is not a multiple of processor width?
  7. Why are loops slow in R?
  8. Is recursion ever faster than looping?
  9. Why are difference lists more efficient than regular concatenation in Haskell?
  10. How to clone git repository with specific revision/changeset?
  11. Apache Spark: map vs mapPartitions?
  12. How much overhead does SSL impose?
  13. CSS3 Transitions: Is “transition: all” slower than “transition: x”?
  14. Faster way to initialize arrays via empty matrix multiplication? (Matlab)
  15. When, if ever, is loop unrolling still useful?
  16. Size of store buffers on Intel hardware? What exactly is a store buffer?
  17. Avoid stalling pipeline by calculating conditional early
  18. Run-length decoding in MATLAB
  19. Android studio takes too much memory
  20. Most efficient list to data.frame method?
  21. x86_64: is IMUL faster than 2x SHL + 2x ADD?
  22. Has anyone actually implemented a Fibonacci-Heap efficiently?
  23. Number of partitions in RDD and performance in Spark
  24. Order of the code and performance
  25. SUMIFS function in Google Spreadsheet
  26. Optimizing File Cacheing and HTTP2
  27. latency vs throughput in intel intrinsics
  28. Performance of using static methods vs instantiating the class containing the methods
  29. How to get Git to clone into current directory
  30. Network throttling with chrome and selenium

Leave a Comment