|
|
Mercurial supports several ways to specify revisions.
|
|
|
|
|
|
Specifying single revisions
|
|
|
===========================
|
|
|
|
|
|
A plain integer is treated as a revision number. Negative integers are
|
|
|
treated as sequential offsets from the tip, with -1 denoting the tip,
|
|
|
-2 denoting the revision prior to the tip, and so forth.
|
|
|
|
|
|
A 40-digit hexadecimal string is treated as a unique revision identifier.
|
|
|
A hexadecimal string less than 40 characters long is treated as a
|
|
|
unique revision identifier and is referred to as a short-form
|
|
|
identifier. A short-form identifier is only valid if it is the prefix
|
|
|
of exactly one full-length identifier.
|
|
|
|
|
|
Any other string is treated as a bookmark, tag, or branch name. A
|
|
|
bookmark is a movable pointer to a revision. A tag is a permanent name
|
|
|
associated with a revision. A branch name denotes the tipmost open branch head
|
|
|
of that branch - or if they are all closed, the tipmost closed head of the
|
|
|
branch. Bookmark, tag, and branch names must not contain the ":" character.
|
|
|
|
|
|
The reserved name "tip" always identifies the most recent revision.
|
|
|
|
|
|
The reserved name "null" indicates the null revision. This is the
|
|
|
revision of an empty repository, and the parent of revision 0.
|
|
|
|
|
|
The reserved name "." indicates the working directory parent. If no
|
|
|
working directory is checked out, it is equivalent to null. If an
|
|
|
uncommitted merge is in progress, "." is the revision of the first
|
|
|
parent.
|
|
|
|
|
|
Finally, commands that expect a single revision (like ``hg update``) also
|
|
|
accept revsets (see below for details). When given a revset, they use the
|
|
|
last revision of the revset. A few commands accept two single revisions
|
|
|
(like ``hg diff``). When given a revset, they use the first and the last
|
|
|
revisions of the revset.
|
|
|
|
|
|
Specifying multiple revisions
|
|
|
=============================
|
|
|
|
|
|
Mercurial supports a functional language for selecting a set of
|
|
|
revisions. Expressions in this language are called revsets.
|
|
|
|
|
|
The language supports a number of predicates which are joined by infix
|
|
|
operators. Parenthesis can be used for grouping.
|
|
|
|
|
|
Identifiers such as branch names may need quoting with single or
|
|
|
double quotes if they contain characters like ``-`` or if they match
|
|
|
one of the predefined predicates.
|
|
|
|
|
|
Special characters can be used in quoted identifiers by escaping them,
|
|
|
e.g., ``\n`` is interpreted as a newline. To prevent them from being
|
|
|
interpreted, strings can be prefixed with ``r``, e.g. ``r'...'``.
|
|
|
|
|
|
Operators
|
|
|
=========
|
|
|
|
|
|
There is a single prefix operator:
|
|
|
|
|
|
``not x``
|
|
|
Changesets not in x. Short form is ``! x``.
|
|
|
|
|
|
These are the supported infix operators:
|
|
|
|
|
|
``x::y``
|
|
|
A DAG range, meaning all changesets that are descendants of x and
|
|
|
ancestors of y, including x and y themselves. If the first endpoint
|
|
|
is left out, this is equivalent to ``ancestors(y)``, if the second
|
|
|
is left out it is equivalent to ``descendants(x)``.
|
|
|
|
|
|
An alternative syntax is ``x..y``.
|
|
|
|
|
|
``x:y``
|
|
|
All changesets with revision numbers between x and y, both
|
|
|
inclusive. Either endpoint can be left out, they default to 0 and
|
|
|
tip.
|
|
|
|
|
|
``x and y``
|
|
|
The intersection of changesets in x and y. Short form is ``x & y``.
|
|
|
|
|
|
``x or y``
|
|
|
The union of changesets in x and y. There are two alternative short
|
|
|
forms: ``x | y`` and ``x + y``.
|
|
|
|
|
|
``x - y``
|
|
|
Changesets in x but not in y.
|
|
|
|
|
|
``x % y``
|
|
|
Changesets that are ancestors of x but not ancestors of y (i.e. ::x - ::y).
|
|
|
This is shorthand notation for ``only(x, y)`` (see below). The second
|
|
|
argument is optional and, if left out, is equivalent to ``only(x)``.
|
|
|
|
|
|
``x^n``
|
|
|
The nth parent of x, n == 0, 1, or 2.
|
|
|
For n == 0, x; for n == 1, the first parent of each changeset in x;
|
|
|
for n == 2, the second parent of changeset in x.
|
|
|
|
|
|
``x~n``
|
|
|
The nth first ancestor of x; ``x~0`` is x; ``x~3`` is ``x^^^``.
|
|
|
For n < 0, the nth unambiguous descendent of x.
|
|
|
|
|
|
``x ## y``
|
|
|
Concatenate strings and identifiers into one string.
|
|
|
|
|
|
All other prefix, infix and postfix operators have lower priority than
|
|
|
``##``. For example, ``a1 ## a2~2`` is equivalent to ``(a1 ## a2)~2``.
|
|
|
|
|
|
For example::
|
|
|
|
|
|
[revsetalias]
|
|
|
issue(a1) = grep(r'\bissue[ :]?' ## a1 ## r'\b|\bbug\(' ## a1 ## r'\)')
|
|
|
|
|
|
``issue(1234)`` is equivalent to
|
|
|
``grep(r'\bissue[ :]?1234\b|\bbug\(1234\)')``
|
|
|
in this case. This matches against all of "issue 1234", "issue:1234",
|
|
|
"issue1234" and "bug(1234)".
|
|
|
|
|
|
There is a single postfix operator:
|
|
|
|
|
|
``x^``
|
|
|
Equivalent to ``x^1``, the first parent of each changeset in x.
|
|
|
|
|
|
Patterns
|
|
|
========
|
|
|
|
|
|
Where noted, predicates that perform string matching can accept a pattern
|
|
|
string. The pattern may be either a literal, or a regular expression. If the
|
|
|
pattern starts with ``re:``, the remainder of the pattern is treated as a
|
|
|
regular expression. Otherwise, it is treated as a literal. To match a pattern
|
|
|
that actually starts with ``re:``, use the prefix ``literal:``.
|
|
|
|
|
|
Matching is case-sensitive, unless otherwise noted. To perform a case-
|
|
|
insensitive match on a case-sensitive predicate, use a regular expression,
|
|
|
prefixed with ``(?i)``.
|
|
|
|
|
|
For example, ``tag(r're:(?i)release')`` matches "release" or "RELEASE"
|
|
|
or "Release", etc.
|
|
|
|
|
|
Predicates
|
|
|
==========
|
|
|
|
|
|
The following predicates are supported:
|
|
|
|
|
|
.. predicatesmarker
|
|
|
|
|
|
Aliases
|
|
|
=======
|
|
|
|
|
|
New predicates (known as "aliases") can be defined, using any combination of
|
|
|
existing predicates or other aliases. An alias definition looks like::
|
|
|
|
|
|
<alias> = <definition>
|
|
|
|
|
|
in the ``revsetalias`` section of a Mercurial configuration file. Arguments
|
|
|
of the form `a1`, `a2`, etc. are substituted from the alias into the
|
|
|
definition.
|
|
|
|
|
|
For example,
|
|
|
|
|
|
::
|
|
|
|
|
|
[revsetalias]
|
|
|
h = heads()
|
|
|
d(s) = sort(s, date)
|
|
|
rs(s, k) = reverse(sort(s, k))
|
|
|
|
|
|
defines three aliases, ``h``, ``d``, and ``rs``. ``rs(0:tip, author)`` is
|
|
|
exactly equivalent to ``reverse(sort(0:tip, author))``.
|
|
|
|
|
|
Equivalents
|
|
|
===========
|
|
|
|
|
|
Command line equivalents for :hg:`log`::
|
|
|
|
|
|
-f -> ::.
|
|
|
-d x -> date(x)
|
|
|
-k x -> keyword(x)
|
|
|
-m -> merge()
|
|
|
-u x -> user(x)
|
|
|
-b x -> branch(x)
|
|
|
-P x -> !::x
|
|
|
-l x -> limit(expr, x)
|
|
|
|
|
|
Examples
|
|
|
========
|
|
|
|
|
|
Some sample queries:
|
|
|
|
|
|
- Changesets on the default branch::
|
|
|
|
|
|
hg log -r "branch(default)"
|
|
|
|
|
|
- Changesets on the default branch since tag 1.5 (excluding merges)::
|
|
|
|
|
|
hg log -r "branch(default) and 1.5:: and not merge()"
|
|
|
|
|
|
- Open branch heads::
|
|
|
|
|
|
hg log -r "head() and not closed()"
|
|
|
|
|
|
- Changesets between tags 1.3 and 1.5 mentioning "bug" that affect
|
|
|
``hgext/*``::
|
|
|
|
|
|
hg log -r "1.3::1.5 and keyword(bug) and file('hgext/*')"
|
|
|
|
|
|
- Changesets committed in May 2008, sorted by user::
|
|
|
|
|
|
hg log -r "sort(date('May 2008'), user)"
|
|
|
|
|
|
- Changesets mentioning "bug" or "issue" that are not in a tagged
|
|
|
release::
|
|
|
|
|
|
hg log -r "(keyword(bug) or keyword(issue)) and not ancestors(tag())"
|
|
|
|
|
|
- Update to the commit that bookmark @ is pointing to, without activating the
|
|
|
bookmark (this works because the last revision of the revset is used)::
|
|
|
|
|
|
hg update :@
|
|
|
|
|
|
- Show diff between tags 1.3 and 1.5 (this works because the first and the
|
|
|
last revisions of the revset are used)::
|
|
|
|
|
|
hg diff -r 1.3::1.5
|
|
|
|
