NAME
git-update-index - Register file contents in the working tree to the indexSYNOPSIS
git update-index [--add] [--remove | --force-remove] [--replace] [--refresh] [-q] [--unmerged] [--ignore-missing] [(--cacheinfo <mode>,<object>,<file>)...] [--chmod=(+|-)x] [--[no-]assume-unchanged] [--[no-]skip-worktree] [--[no-]ignore-skip-worktree-entries] [--[no-]fsmonitor-valid] [--ignore-submodules] [--[no-]split-index] [--[no-|test-|force-]untracked-cache] [--[no-]fsmonitor] [--really-refresh] [--unresolve] [--again | -g] [--info-only] [--index-info] [-z] [--stdin] [--index-version <n>] [--verbose] [--] [<file>...]
DESCRIPTION
Modifies the index. Each file mentioned is updated into the index and any unmerged or needs updating state is cleared.OPTIONS
--addIf a specified file isn’t in the index
already then it’s added. Default behaviour is to ignore new
files.
--remove
If a specified file is in the index but is
missing then it’s removed. Default behavior is to ignore removed
file.
--refresh
Looks at the current index and checks to see
if merges or updates are needed by checking stat() information.
-q
Quiet. If --refresh finds that the index needs
an update, the default behavior is to error out. This option makes git
update-index continue anyway.
--ignore-submodules
Do not try to update submodules. This option
is only respected when passed before --refresh.
--unmerged
If --refresh finds unmerged changes in the
index, the default behavior is to error out. This option makes git
update-index continue anyway.
--ignore-missing
Ignores missing files during a --refresh
--cacheinfo <mode>,<object>,<path>, --cacheinfo <mode>
<object> <path>
Directly insert the specified info into the
index. For backward compatibility, you can also give these three arguments as
three separate parameters, but new users are encouraged to use a
single-parameter form.
--index-info
Read index information from stdin.
--chmod=(+|-)x
Set the execute permissions on the updated
files.
--[no-]assume-unchanged
When this flag is specified, the object names
recorded for the paths are not updated. Instead, this option sets/unsets the
"assume unchanged" bit for the paths. When the "assume
unchanged" bit is on, the user promises not to change the file and allows
Git to assume that the working tree file matches what is recorded in the
index. If you want to change the working tree file, you need to unset the bit
to tell Git. This is sometimes helpful when working with a big project on a
filesystem that has very slow lstat(2) system call (e.g. cifs).
Git will fail (gracefully) in case it needs to modify this file in the index
e.g. when merging in a commit; thus, in case the assumed-untracked file is
changed upstream, you will need to handle the situation manually.
--really-refresh
Like --refresh, but checks stat
information unconditionally, without regard to the "assume
unchanged" setting.
--[no-]skip-worktree
When one of these flags is specified, the
object name recorded for the paths are not updated. Instead, these options set
and unset the "skip-worktree" bit for the paths. See section
"Skip-worktree bit" below for more information.
--[no-]ignore-skip-worktree-entries
Do not remove skip-worktree (AKA
"index-only") entries even when the --remove option was
specified.
--[no-]fsmonitor-valid
When one of these flags is specified, the
object name recorded for the paths are not updated. Instead, these options set
and unset the "fsmonitor valid" bit for the paths. See section
"File System Monitor" below for more information.
-g, --again
Runs git update-index itself on the
paths whose index entries are different from those from the HEAD
commit.
--unresolve
Restores the unmerged or needs
updating state of a file during a merge if it was cleared by
accident.
--info-only
Do not create objects in the object database
for all <file> arguments that follow this flag; just insert their object
IDs into the index.
--force-remove
Remove the file from the index even when the
working directory still has such a file. (Implies --remove.)
--replace
By default, when a file path exists in
the index, git update-index refuses an attempt to add path/file.
Similarly if a file path/file exists, a file path cannot be
added. With --replace flag, existing entries that conflict with the entry
being added are automatically removed with warning messages.
--stdin
Instead of taking list of paths from the
command line, read list of paths from the standard input. Paths are separated
by LF (i.e. one path per line) by default.
--verbose
Report what is being added and removed from
index.
--index-version <n>
Write the resulting index out in the named
on-disk format version. Supported versions are 2, 3 and 4. The current default
version is 2 or 3, depending on whether extra features are used, such as
git add -N.
Version 4 performs a simple pathname compression that reduces index size by
30%-50% on large repositories, which results in faster load time. Version 4 is
relatively young (first released in 1.8.0 in October 2012). Other Git
implementations such as JGit and libgit2 may not support it yet.
-z
Only meaningful with --stdin or
--index-info; paths are separated with NUL character instead of
LF.
--split-index, --no-split-index
Enable or disable split index mode. If
split-index mode is already enabled and --split-index is given again,
all changes in $GIT_DIR/index are pushed back to the shared index file.
These options take effect whatever the value of the core.splitIndex
configuration variable (see git-config(1)). But a warning is emitted
when the change goes against the configured value, as the configured value
will take effect next time the index is read and this will remove the intended
effect of the option.
--untracked-cache, --no-untracked-cache
Enable or disable untracked cache feature.
Please use --test-untracked-cache before enabling it.
These options take effect whatever the value of the core.untrackedCache
configuration variable (see git-config(1)). But a warning is emitted
when the change goes against the configured value, as the configured value
will take effect next time the index is read and this will remove the intended
effect of the option.
--test-untracked-cache
Only perform tests on the working directory to
make sure untracked cache can be used. You have to manually enable untracked
cache using --untracked-cache or --force-untracked-cache or the
core.untrackedCache configuration variable afterwards if you really
want to use it. If a test fails the exit code is 1 and a message explains what
is not working as needed, otherwise the exit code is 0 and OK is
printed.
--force-untracked-cache
Same as --untracked-cache. Provided for
backwards compatibility with older versions of Git where
--untracked-cache used to imply --test-untracked-cache but this
option would enable the extension unconditionally.
--fsmonitor, --no-fsmonitor
Enable or disable files system monitor
feature. These options take effect whatever the value of the
core.fsmonitor configuration variable (see git-config(1)). But a
warning is emitted when the change goes against the configured value, as the
configured value will take effect next time the index is read and this will
remove the intended effect of the option.
--
Do not interpret any more arguments as
options.
<file>
Files to act on. Note that files beginning
with . are discarded. This includes ./file and
dir/./file. If you don’t want this, then use cleaner names. The
same applies to directories ending / and paths with //
USING --REFRESH
--refresh does not calculate a new sha1 file or bring the index up to date for mode/content changes. But what it does do is to "re-match" the stat information of a file with the index, so that you can refresh the index for a file that hasn’t been changed but where the stat entry is out of date.USING --CACHEINFO OR --INFO-ONLY
--cacheinfo is used to register a file that is not in the current working directory. This is useful for minimum-checkout merging.$ git update-index --add --cacheinfo <mode>,<sha1>,<path>
USING --INDEX-INFO
--index-info is a more powerful mechanism that lets you feed multiple entry definitions from the standard input, and designed specifically for scripts. It can take inputs of three formats: 1.mode SP type SP sha1 TAB path
This format is to stuff git ls-tree output into the index.
2.mode SP sha1 SP stage TAB path
This format is to put higher order stages into the index file and matches git
ls-files --stage output.
3.mode SP sha1 TAB path
This format is no longer produced by any Git command, but is and will continue
to be supported by update-index --index-info.
$ git ls-files -s 100644 8a1218a1024a212bb3db30becd860315f9f3ac52 0 frotz
$ git update-index --index-info 0 0000000000000000000000000000000000000000 frotz 100644 8a1218a1024a212bb3db30becd860315f9f3ac52 1 frotz 100755 8a1218a1024a212bb3db30becd860315f9f3ac52 2 frotz
$ git ls-files -s 100644 8a1218a1024a212bb3db30becd860315f9f3ac52 1 frotz 100755 8a1218a1024a212bb3db30becd860315f9f3ac52 2 frotz
USING “ASSUME UNCHANGED” BIT
Many operations in Git depend on your filesystem to have an efficient lstat(2) implementation, so that st_mtime information for working tree files can be cheaply checked to see if the file contents have changed from the version recorded in the index file. Unfortunately, some filesystems have inefficient lstat(2). If your filesystem is one of them, you can set "assume unchanged" bit to paths you have not changed to cause Git not to do this check. Note that setting this bit on a path does not mean Git will check the contents of the file to see if it has changed — it makes Git to omit any checking and assume it has not changed. When you make changes to working tree files, you have to explicitly tell Git about it by dropping "assume unchanged" bit, either before or after you modify them.EXAMPLES
To update and refresh only the files already checked out:$ git checkout-index -n -f -a && git update-index --ignore-missing --refresh
$ git update-index --really-refresh (1) $ git update-index --no-assume-unchanged foo.c (2) $ git diff --name-only (3) $ edit foo.c $ git diff --name-only (4) M foo.c $ git update-index foo.c (5) $ git diff --name-only (6) $ edit foo.c $ git diff --name-only (7) $ git update-index --no-assume-unchanged foo.c (8) $ git diff --name-only (9) M foo.c
SKIP-WORKTREE BIT
Skip-worktree bit can be defined in one (long) sentence: Tell git to avoid writing the file to the working directory when reasonably possible, and treat the file as unchanged when it is not present in the working directory.SPLIT INDEX
This mode is designed for repositories with very large indexes, and aims at reducing the time it takes to repeatedly write these indexes.UNTRACKED CACHE
This cache is meant to speed up commands that involve determining untracked files such as git status.$ git -c core.untrackedCache=false status
FILE SYSTEM MONITOR
This feature is intended to speed up git operations for repos that have large working directories.CONFIGURATION
The command honors core.filemode configuration variable. If your repository is on a filesystem whose executable bits are unreliable, this should be set to false (see git-config(1)). This causes the command to ignore differences in file modes recorded in the index and the file mode on the filesystem if they differ only on executable bit. On such an unfortunate filesystem, you may need to use git update-index --chmod=.NOTES
Users often try to use the assume-unchanged and skip-worktree bits to tell Git to ignore changes to files that are tracked. This does not work as expected, since Git may still check working tree files against the index when performing certain operations. In general, Git does not provide a way to ignore changes to tracked files, so alternate solutions are recommended.SEE ALSO
git-config(1), git-add(1), git-ls-files(1)GIT
Part of the git(1) suite02/28/2023 | Git 2.39.2 |