search..
No manual entry for -- in section 1
GIT-UPDATE-REF(1)		   Git Manual		      GIT-UPDATE-REF(1)

NAME
       git-update-ref - Update the object name stored in a ref safely

SYNOPSIS
       git update-ref [-m <reason>] [--no-deref] (-d <ref> [<old-oid>] | [--create-reflog] <ref> <new-oid> [<old-oid>] | --stdin [-z])

DESCRIPTION
       Given two arguments, stores the <new-oid> in the <ref>, possibly
       dereferencing the symbolic refs. E.g. git update-ref HEAD <new-oid>
       updates the current branch head to the new object.

       Given three arguments, stores the <new-oid> in the <ref>, possibly
       dereferencing the symbolic refs, after verifying that the current value
       of the <ref> matches <old-oid>. E.g. git update-ref refs/heads/master
       <new-oid> <old-oid> updates the master branch head to <new-oid> only if
       its current value is <old-oid>. You can specify 40 "0" or an empty
       string as <old-oid> to make sure that the ref you are creating does not
       exist.

       It also allows a "ref" file to be a symbolic pointer to another ref file
       by starting with the four-byte header sequence of "ref:".

       More importantly, it allows the update of a ref file to follow these
       symbolic pointers, whether they are symlinks or these "regular file
       symbolic refs". It follows real symlinks only if they start with
       "refs/": otherwise it will just try to read them and update them as a
       regular file (i.e. it will allow the filesystem to follow them, but will
       overwrite such a symlink to somewhere else with a regular filename).

       If --no-deref is given, <ref> itself is overwritten, rather than the
       result of following the symbolic pointers.

       In general, using

	   git update-ref HEAD "$head"

       should be a lot safer than doing

	   echo "$head" > "$GIT_DIR/HEAD"

       both from a symlink following standpoint and an error checking
       standpoint. The "refs/" rule for symlinks means that symlinks that point
       to "outside" the tree are safe: they'll be followed for reading but not
       for writing (so we'll never write through a ref symlink to some other
       tree, if you have copied a whole archive by creating a symlink tree).

       With -d flag, it deletes the named <ref> after verifying it still
       contains <old-oid>.

       With --stdin, update-ref reads instructions from standard input and
       performs all modifications together. Specify commands of the form:

	   update SP <ref> SP <new-oid> [SP <old-oid>] LF
	   create SP <ref> SP <new-oid> LF
	   delete SP <ref> [SP <old-oid>] LF
	   verify SP <ref> [SP <old-oid>] LF
	   symref-update SP <ref> SP <new-target> [SP (ref SP <old-target> | oid SP <old-oid>)] LF
	   symref-create SP <ref> SP <new-target> LF
	   symref-delete SP <ref> [SP <old-target>] LF
	   symref-verify SP <ref> [SP <old-target>] LF
	   option SP <opt> LF
	   start LF
	   prepare LF
	   commit LF
	   abort LF

       With --create-reflog, update-ref will create a reflog for each ref even
       if one would not ordinarily be created.

       Quote fields containing whitespace as if they were strings in C source
       code; i.e., surrounded by double-quotes and with backslash escapes. Use
       40 "0" characters or the empty string to specify a zero value. To
       specify a missing value, omit the value and its preceding SP entirely.

       Alternatively, use -z to specify in NUL-terminated format, without
       quoting:

	   update SP <ref> NUL <new-oid> NUL [<old-oid>] NUL
	   create SP <ref> NUL <new-oid> NUL
	   delete SP <ref> NUL [<old-oid>] NUL
	   verify SP <ref> NUL [<old-oid>] NUL
	   symref-update SP <ref> NUL <new-target> [NUL (ref NUL <old-target> | oid NUL <old-oid>)] NUL
	   symref-create SP <ref> NUL <new-target> NUL
	   symref-delete SP <ref> [NUL <old-target>] NUL
	   symref-verify SP <ref> [NUL <old-target>] NUL
	   option SP <opt> NUL
	   start NUL
	   prepare NUL
	   commit NUL
	   abort NUL

       In this format, use 40 "0" to specify a zero value, and use the empty
       string to specify a missing value.

       In either format, values can be specified in any form that Git
       recognizes as an object name. Commands in any other format or a repeated
       <ref> produce an error. Command meanings are:

       update
	   Set <ref> to <new-oid> after verifying <old-oid>, if given. Specify
	   a zero <new-oid> to ensure the ref does not exist after the update
	   and/or a zero <old-oid> to make sure the ref does not exist before
	   the update.

       create
	   Create <ref> with <new-oid> after verifying it does not exist. The
	   given <new-oid> may not be zero.

       delete
	   Delete <ref> after verifying it exists with <old-oid>, if given. If
	   given, <old-oid> may not be zero.

       symref-update
	   Set <ref> to <new-target> after verifying <old-target> or <old-oid>,
	   if given. Specify a zero <old-oid> to ensure that the ref does not
	   exist before the update.

       verify
	   Verify <ref> against <old-oid> but do not change it. If <old-oid> is
	   zero or missing, the ref must not exist.

       symref-create: Create symbolic ref <ref> with <new-target> after
       verifying it does not exist.

       symref-delete
	   Delete <ref> after verifying it exists with <old-target>, if given.

       symref-verify
	   Verify symbolic <ref> against <old-target> but do not change it. If
	   <old-target> is missing, the ref must not exist. Can only be used in
	   no-deref mode.

       option
	   Modify the behavior of the next command naming a <ref>. The only
	   valid option is no-deref to avoid dereferencing a symbolic ref.

       start
	   Start a transaction. In contrast to a non-transactional session, a
	   transaction will automatically abort if the session ends without an
	   explicit commit. This command may create a new empty transaction
	   when the current one has been committed or aborted already.

       prepare
	   Prepare to commit the transaction. This will create lock files for
	   all queued reference updates. If one reference could not be locked,
	   the transaction will be aborted.

       commit
	   Commit all reference updates queued for the transaction, ending the
	   transaction.

       abort
	   Abort the transaction, releasing all locks if the transaction is in
	   prepared state.

       If all <ref>s can be locked with matching <old-oid>s simultaneously, all
       modifications are performed. Otherwise, no modifications are performed.
       Note that while each individual <ref> is updated or deleted atomically,
       a concurrent reader may still see a subset of the modifications.

LOGGING UPDATES
       If config parameter "core.logAllRefUpdates" is true and the ref is one
       under "refs/heads/", "refs/remotes/", "refs/notes/", or a pseudoref like
       HEAD or ORIG_HEAD; or the file "$GIT_DIR/logs/<ref>" exists then git
       update-ref will append a line to the log file "$GIT_DIR/logs/<ref>"
       (dereferencing all symbolic refs before creating the log name)
       describing the change in ref value. Log lines are formatted as:

	   oldsha1 SP newsha1 SP committer LF

       Where "oldsha1" is the 40 character hexadecimal value previously stored
       in <ref>, "newsha1" is the 40 character hexadecimal value of <new-oid>
       and "committer" is the committer's name, email address and date in the
       standard Git committer ident format.

       Optionally with -m:

	   oldsha1 SP newsha1 SP committer TAB message LF

       Where all fields are as described above and "message" is the value
       supplied to the -m option.

       An update will fail (without changing <ref>) if the current user is
       unable to create a new log file, append to the existing log file or does
       not have committer information available.

GIT
       Part of the git(1) suite

Git 2.47.3			   07/30/2025		      GIT-UPDATE-REF(1)