This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11662

dirstate-v2: Separate HAS_FILE_MTIME and HAS_DIRECTORY_MTIME flags
ClosedPublic

Authored by SimonSapin on Oct 14 2021, 11:00 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGf7fd629ffb98: dirstate-v2: Separate HAS_FILE_MTIME and HAS_DIRECTORY_MTIME flags
Summary

Previously the same flag was used, with its meaning based on whether the node
otherwise identifies a file tracked anywhere.

In addition to being more explicit, this enables storing a directory mtime
if a given path used to be tracked in a parent commit (so the dirstate still
has data about it) but became a directory in the working copy.
(However this is not done yet as it would require a larger change,
replacing the dirstate_map::NodeData enum with struct fields.)

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Oct 14 2021, 11:00 AM
pulkit accepted this revision.Oct 14 2021, 2:46 PM
This revision is now accepted and ready to land.Oct 14 2021, 2:46 PM

Revision Contents
Changeset List

Diff 30819

mercurial/cext/parsers.c

t->flags |= dirstate_flag_has_meaningful_data; t->flags |= dirstate_flag_has_meaningful_data;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
} else { } else {
t->mode = 0; t->mode = 0;
t->size = 0; t->size = 0;
} }
if (has_meaningful_mtime) { if (has_meaningful_mtime) {
t->flags |= dirstate_flag_has_meaningful_mtime; t->flags |= dirstate_flag_has_file_mtime;
t->mtime = mtime; t->mtime = mtime;
} else { } else {
t->mtime = 0; t->mtime = 0;
} }
return (PyObject *)t; return (PyObject *)t;
} }
static void dirstate_item_dealloc(PyObject *o) static void dirstate_item_dealloc(PyObject *o)
return dirstate_v1_nonnormal; return dirstate_v1_nonnormal;
} }
} }
static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self) static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)
{ {
if (dirstate_item_c_removed(self)) { if (dirstate_item_c_removed(self)) {
return 0; return 0;
} else if (!(self->flags & dirstate_flag_has_meaningful_mtime) || } else if (!(self->flags & dirstate_flag_has_file_mtime) ||
!(self->flags & dirstate_flag_p1_tracked) || !(self->flags & dirstate_flag_p1_tracked) ||
!(self->flags & dirstate_flag_wc_tracked) || !(self->flags & dirstate_flag_wc_tracked) ||
(self->flags & dirstate_flag_p2_info)) { (self->flags & dirstate_flag_p2_info)) {
return ambiguous_time; return ambiguous_time;
} else { } else {
return self->mtime; return self->mtime;
} }
} }
dirstate_flag_p1_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data); dirstate_flag_has_meaningful_data);
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
} else { } else {
t->flags = (dirstate_flag_wc_tracked | t->flags = (dirstate_flag_wc_tracked |
dirstate_flag_p1_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_meaningful_mtime); dirstate_flag_has_file_mtime);
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
} }
} else { } else {
PyErr_Format(PyExc_RuntimeError, PyErr_Format(PyExc_RuntimeError,
"unknown state: `%c` (%d, %d, %d)", state, mode, "unknown state: `%c` (%d, %d, %d)", state, mode,
size, mtime, NULL); size, mtime, NULL);
} }
return (PyObject *)t; return (PyObject *)t;
}; };
/* This means the next status call will have to actually check its content /* This means the next status call will have to actually check its content
to make sure it is correct. */ to make sure it is correct. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
self->flags &= ~dirstate_flag_has_meaningful_mtime; self->flags &= ~dirstate_flag_has_file_mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* See docstring of the python implementation for details */ /* See docstring of the python implementation for details */
static PyObject *dirstate_item_set_clean(dirstateItemObject *self, static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
PyObject *args) PyObject *args)
{ {
int size, mode, mtime; int size, mode, mtime;
if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) { if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
return NULL; return NULL;
} }
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_meaningful_mtime; dirstate_flag_has_file_mtime;
self->mode = mode; self->mode = mode;
self->size = size; self->size = size;
self->mtime = mtime; self->mtime = mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_tracked(dirstateItemObject *self) static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
{ {
self->flags |= dirstate_flag_wc_tracked; self->flags |= dirstate_flag_wc_tracked;
self->flags &= ~dirstate_flag_has_meaningful_mtime; self->flags &= ~dirstate_flag_has_file_mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_untracked(dirstateItemObject *self) static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
{ {
self->flags &= ~dirstate_flag_wc_tracked; self->flags &= ~dirstate_flag_wc_tracked;
self->mode = 0; self->mode = 0;
self->mtime = 0; self->mtime = 0;
self->size = 0; self->size = 0;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self) static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
{ {
if (self->flags & dirstate_flag_p2_info) { if (self->flags & dirstate_flag_p2_info) {
self->flags &= ~(dirstate_flag_p2_info | self->flags &= ~(dirstate_flag_p2_info |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_meaningful_mtime); dirstate_flag_has_file_mtime);
self->mode = 0; self->mode = 0;
self->mtime = 0; self->mtime = 0;
self->size = 0; self->size = 0;
} }
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyMethodDef dirstate_item_methods[] = { static PyMethodDef dirstate_item_methods[] = {
{"v2_data", (PyCFunction)dirstate_item_v2_data, METH_NOARGS, {"v2_data", (PyCFunction)dirstate_item_v2_data, METH_NOARGS,

mercurial/cext/util.h

int mtime; int mtime;
} dirstateItemObject; } dirstateItemObject;
/* clang-format on */ /* clang-format on */
static const unsigned char dirstate_flag_wc_tracked = 1; static const unsigned char dirstate_flag_wc_tracked = 1;
static const unsigned char dirstate_flag_p1_tracked = 1 << 1; static const unsigned char dirstate_flag_p1_tracked = 1 << 1;
static const unsigned char dirstate_flag_p2_info = 1 << 2; static const unsigned char dirstate_flag_p2_info = 1 << 2;
static const unsigned char dirstate_flag_has_meaningful_data = 1 << 3; static const unsigned char dirstate_flag_has_meaningful_data = 1 << 3;
static const unsigned char dirstate_flag_has_meaningful_mtime = 1 << 4; static const unsigned char dirstate_flag_has_file_mtime = 1 << 4;
static const unsigned char dirstate_flag_mode_exec_perm = 1 << 5; static const unsigned char dirstate_flag_has_directory_mtime = 1 << 5;
static const unsigned char dirstate_flag_mode_is_symlink = 1 << 6; static const unsigned char dirstate_flag_mode_exec_perm = 1 << 6;
static const unsigned char dirstate_flag_mode_is_symlink = 1 << 7;
extern PyTypeObject dirstateItemType; extern PyTypeObject dirstateItemType;
#define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType) #define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType)
#ifndef MIN #ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b)) #define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif #endif
/* VC9 doesn't include bool and lacks stdbool.h based on my searching */ /* VC9 doesn't include bool and lacks stdbool.h based on my searching */

mercurial/helptext/internals/dirstate-v2.txt

* Offset 30: * Offset 30:
A `flags` fields that packs some boolean values as bits of a 16-bit integer. A `flags` fields that packs some boolean values as bits of a 16-bit integer.
Starting from least-significant, bit masks are:: Starting from least-significant, bit masks are::
WDIR_TRACKED = 1 << 0 WDIR_TRACKED = 1 << 0
P1_TRACKED = 1 << 1 P1_TRACKED = 1 << 1
P2_INFO = 1 << 2 P2_INFO = 1 << 2
HAS_MODE_AND_SIZE = 1 << 3 HAS_MODE_AND_SIZE = 1 << 3
HAS_MTIME = 1 << 4 HAS_FILE_MTIME = 1 << 4
MODE_EXEC_PERM = 1 << 5 HAS_DIRECTORY_MTIME = 1 << 5
MODE_IS_SYMLINK = 1 << 6 MODE_EXEC_PERM = 1 << 6
MODE_IS_SYMLINK = 1 << 7
The meaning of each bit is described below. The meaning of each bit is described below.
Other bits are unset. Other bits are unset.
They may be assigned meaning if the future, They may be assigned meaning if the future,
with the limitation that Mercurial versions that pre-date such meaning with the limitation that Mercurial versions that pre-date such meaning
will always reset those bits to unset when writing nodes. will always reset those bits to unset when writing nodes.
(A new node is written for any mutation in its subtree, (A new node is written for any mutation in its subtree,
leaving the bytes of the old node unreachable leaving the bytes of the old node unreachable
until the data file is rewritten entirely.) until the data file is rewritten entirely.)
* Offset 32: * Offset 32:
A `size` field described below, as a 32-bit integer. A `size` field described below, as a 32-bit integer.
Unlike in dirstate-v1, negative values are not used. Unlike in dirstate-v1, negative values are not used.
* Offset 36: * Offset 36:
The seconds component of an `mtime` field described below, The seconds component of an `mtime` field described below,
as a 32-bit integer. as a 32-bit integer.
Unlike in dirstate-v1, negative values are not used. Unlike in dirstate-v1, negative values are not used.
When `mtime` is used, this is number of seconds since the Unix epoch
truncated to its lower 31 bits.
* Offset 40: * Offset 40:
The nanoseconds component of an `mtime` field described below, The nanoseconds component of an `mtime` field described below,
as a 32-bit integer. as a 32-bit integer.
When `mtime` is used,
this is the number of nanoseconds since `mtime.seconds`,
always stritctly less than one billion.
This may be zero if more precision is not available.
(This can happen because of limitations in any of Mercurial, Python,
libc, the operating system, …)
When comparing two mtimes and either has this component set to zero,
the sub-second precision of both should be ignored.
False positives when checking mtime equality due to clock resolution
are always possible and the status algorithm needs to deal with them,
but having too many false negatives could be harmful too.
* (Offset 44: end of this node) * (Offset 44: end of this node)
The meaning of the boolean values packed in `flags` is: The meaning of the boolean values packed in `flags` is:
`WDIR_TRACKED` `WDIR_TRACKED`
Set if the working directory contains a tracked file at this node’s path. Set if the working directory contains a tracked file at this node’s path.
This is typically set and unset by `hg add` and `hg rm`. This is typically set and unset by `hg add` and `hg rm`.
for the file to be clean. for the file to be clean.
- The expected execute permission for the file’s owner - The expected execute permission for the file’s owner
is given by `MODE_EXEC_PERM` is given by `MODE_EXEC_PERM`
- The expected file type is given by `MODE_IS_SIMLINK`: - The expected file type is given by `MODE_IS_SIMLINK`:
a symbolic link if set, or a normal file if unset. a symbolic link if set, or a normal file if unset.
If this is unset the expected size, permission, and file type are unknown. If this is unset the expected size, permission, and file type are unknown.
The `size` field is unused (set to zero). The `size` field is unused (set to zero).
`HAS_MTIME` `HAS_FILE_MTIME`
If unset, the `mtime` field is unused (set to zero). Must be unset for untracked nodes.
If set, it contains a timestamp represented as If this and `HAS_DIRECTORY_MTIME` are both unset,
- the number of seconds since the Unix epoch, the `mtime` field is unused (set to zero).
truncated to its lower 31 bits. If this is set, `mtime` is the modification time
- and the number of nanoseconds since `mtime.seconds`, expected for the file to be considered clean.
always stritctly less than one billion.
This may be zero if more precision is not available. `HAS_DIRECTORY_MTIME`
(This can happen because of limitations in any of Mercurial, Python, Must be unset for file tracked anywhere.
libc, the operating system, …) If this and `HAS_DIRECTORY_MTIME` are both unset,
the `mtime` field is unused (set to zero).
If set for a file tracked anywhere, If this is set, at some point,
`mtime` is the expected modification time for the file to be clean.
If set for an untracked node, at some point,
this path in the working directory was observed: this path in the working directory was observed:
- To be a directory - To be a directory
- With the modification time given in `mtime` - With the modification time given in `mtime`
- That time was already strictly in the past when observed, - That time was already strictly in the past when observed,
meaning that later changes cannot happen in the same clock tick meaning that later changes cannot happen in the same clock tick
and must cause a different modification time and must cause a different modification time
(unless the system clock jumps back and we get unlucky, (unless the system clock jumps back and we get unlucky,

mercurial/pure/parsers.py

# a special value used internally for `time` if the time is ambigeous # a special value used internally for `time` if the time is ambigeous
AMBIGUOUS_TIME = -1 AMBIGUOUS_TIME = -1
# Bits of the `flags` byte inside a node in the file format # Bits of the `flags` byte inside a node in the file format
DIRSTATE_V2_WDIR_TRACKED = 1 << 0 DIRSTATE_V2_WDIR_TRACKED = 1 << 0
DIRSTATE_V2_P1_TRACKED = 1 << 1 DIRSTATE_V2_P1_TRACKED = 1 << 1
DIRSTATE_V2_P2_INFO = 1 << 2 DIRSTATE_V2_P2_INFO = 1 << 2
DIRSTATE_V2_HAS_MODE_AND_SIZE = 1 << 3 DIRSTATE_V2_HAS_MODE_AND_SIZE = 1 << 3
DIRSTATE_V2_HAS_MTIME = 1 << 4 DIRSTATE_V2_HAS_FILE_MTIME = 1 << 4
DIRSTATE_V2_MODE_EXEC_PERM = 1 << 5 _DIRSTATE_V2_HAS_DIRCTORY_MTIME = 1 << 5 # Unused when Rust is not available
DIRSTATE_V2_MODE_IS_SYMLINK = 1 << 6 DIRSTATE_V2_MODE_EXEC_PERM = 1 << 6
DIRSTATE_V2_MODE_IS_SYMLINK = 1 << 7
@attr.s(slots=True, init=False) @attr.s(slots=True, init=False)
class DirstateItem(object): class DirstateItem(object):
"""represent a dirstate entry """represent a dirstate entry
It hold multiple attributes It hold multiple attributes
mode |= stat.S_IFLNK mode |= stat.S_IFLNK
else: else:
mode |= stat.S_IFREG mode |= stat.S_IFREG
return cls( return cls(
wc_tracked=bool(flags & DIRSTATE_V2_WDIR_TRACKED), wc_tracked=bool(flags & DIRSTATE_V2_WDIR_TRACKED),
p1_tracked=bool(flags & DIRSTATE_V2_P1_TRACKED), p1_tracked=bool(flags & DIRSTATE_V2_P1_TRACKED),
p2_info=bool(flags & DIRSTATE_V2_P2_INFO), p2_info=bool(flags & DIRSTATE_V2_P2_INFO),
has_meaningful_data=has_mode_size, has_meaningful_data=has_mode_size,
has_meaningful_mtime=bool(flags & DIRSTATE_V2_HAS_MTIME), has_meaningful_mtime=bool(flags & DIRSTATE_V2_HAS_FILE_MTIME),
parentfiledata=(mode, size, mtime), parentfiledata=(mode, size, mtime),
) )
@classmethod @classmethod
def from_v1_data(cls, state, mode, size, mtime): def from_v1_data(cls, state, mode, size, mtime):
"""Build a new DirstateItem object from V1 data """Build a new DirstateItem object from V1 data
Since the dirstate-v1 format is frozen, the signature of this function Since the dirstate-v1 format is frozen, the signature of this function
flags |= DIRSTATE_V2_P2_INFO flags |= DIRSTATE_V2_P2_INFO
if self._mode is not None and self._size is not None: if self._mode is not None and self._size is not None:
flags |= DIRSTATE_V2_HAS_MODE_AND_SIZE flags |= DIRSTATE_V2_HAS_MODE_AND_SIZE
if self.mode & stat.S_IXUSR: if self.mode & stat.S_IXUSR:
flags |= DIRSTATE_V2_MODE_EXEC_PERM flags |= DIRSTATE_V2_MODE_EXEC_PERM
if stat.S_ISLNK(self.mode): if stat.S_ISLNK(self.mode):
flags |= DIRSTATE_V2_MODE_IS_SYMLINK flags |= DIRSTATE_V2_MODE_IS_SYMLINK
if self._mtime is not None: if self._mtime is not None:
flags |= DIRSTATE_V2_HAS_MTIME flags |= DIRSTATE_V2_HAS_FILE_MTIME
return (flags, self._size or 0, self._mtime or 0) return (flags, self._size or 0, self._mtime or 0)
def v1_state(self): def v1_state(self):
"""return a "state" suitable for v1 serialization""" """return a "state" suitable for v1 serialization"""
if not self.any_tracked: if not self.any_tracked:
# the object has no state to record, this is -currently- # the object has no state to record, this is -currently-
# unsupported # unsupported
raise RuntimeError('untracked item') raise RuntimeError('untracked item')

rust/hg-core/src/dirstate_tree/on_disk.rs

bitflags! { bitflags! {
#[repr(C)] #[repr(C)]
struct Flags: u16 { struct Flags: u16 {
const WDIR_TRACKED = 1 << 0; const WDIR_TRACKED = 1 << 0;
const P1_TRACKED = 1 << 1; const P1_TRACKED = 1 << 1;
const P2_INFO = 1 << 2; const P2_INFO = 1 << 2;
const HAS_MODE_AND_SIZE = 1 << 3; const HAS_MODE_AND_SIZE = 1 << 3;
const HAS_MTIME = 1 << 4; const HAS_FILE_MTIME = 1 << 4;
const MODE_EXEC_PERM = 1 << 5; const HAS_DIRECTORY_MTIME = 1 << 5;
const MODE_IS_SYMLINK = 1 << 6; const MODE_EXEC_PERM = 1 << 6;
const MODE_IS_SYMLINK = 1 << 7;
} }
} }
/// Duration since the Unix epoch /// Duration since the Unix epoch
#[derive(BytesCast, Copy, Clone)] #[derive(BytesCast, Copy, Clone)]
#[repr(C)] #[repr(C)]
struct PackedTruncatedTimestamp { struct PackedTruncatedTimestamp {
truncated_seconds: U32Be, truncated_seconds: U32Be,
} else { } else {
Ok(dirstate_map::NodeData::None) Ok(dirstate_map::NodeData::None)
} }
} }
pub(super) fn cached_directory_mtime( pub(super) fn cached_directory_mtime(
&self, &self,
) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> { ) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> {
Ok( if self.flags().contains(Flags::HAS_DIRECTORY_MTIME) {
if self.flags().contains(Flags::HAS_MTIME) && !self.has_entry() { if self.flags().contains(Flags::HAS_FILE_MTIME) {
Some(self.mtime.try_into()?) Err(DirstateV2ParseError)
} else { } else {
None Ok(Some(self.mtime.try_into()?))
}, }
) } else {
Ok(None)
}
} }
fn synthesize_unix_mode(&self) -> u32 { fn synthesize_unix_mode(&self) -> u32 {
let file_type = if self.flags().contains(Flags::MODE_IS_SYMLINK) { let file_type = if self.flags().contains(Flags::MODE_IS_SYMLINK) {
libc::S_IFLNK libc::S_IFLNK
} else { } else {
libc::S_IFREG libc::S_IFREG
}; };
let wdir_tracked = self.flags().contains(Flags::WDIR_TRACKED); let wdir_tracked = self.flags().contains(Flags::WDIR_TRACKED);
let p1_tracked = self.flags().contains(Flags::P1_TRACKED); let p1_tracked = self.flags().contains(Flags::P1_TRACKED);
let p2_info = self.flags().contains(Flags::P2_INFO); let p2_info = self.flags().contains(Flags::P2_INFO);
let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE) { let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE) {
Some((self.synthesize_unix_mode(), self.size.into())) Some((self.synthesize_unix_mode(), self.size.into()))
} else { } else {
None None
}; };
let mtime = if self.flags().contains(Flags::HAS_MTIME) { let mtime = if self.flags().contains(Flags::HAS_FILE_MTIME) {
Some(self.mtime.truncated_seconds.into()) Some(self.mtime.truncated_seconds.into())
} else { } else {
None None
}; };
DirstateEntry::from_v2_data( DirstateEntry::from_v2_data(
wdir_tracked, wdir_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
flags.set(Flags::MODE_EXEC_PERM, exec_perm); flags.set(Flags::MODE_EXEC_PERM, exec_perm);
flags.set(Flags::MODE_IS_SYMLINK, is_symlink); flags.set(Flags::MODE_IS_SYMLINK, is_symlink);
flags.insert(Flags::HAS_MODE_AND_SIZE); flags.insert(Flags::HAS_MODE_AND_SIZE);
s.into() s.into()
} else { } else {
0.into() 0.into()
}; };
let mtime = if let Some(m) = mtime_opt { let mtime = if let Some(m) = mtime_opt {
flags.insert(Flags::HAS_MTIME); flags.insert(Flags::HAS_FILE_MTIME);
PackedTruncatedTimestamp { PackedTruncatedTimestamp {
truncated_seconds: m.into(), truncated_seconds: m.into(),
nanoseconds: 0.into(), nanoseconds: 0.into(),
} }
} else { } else {
PackedTruncatedTimestamp::null() PackedTruncatedTimestamp::null()
}; };
(flags, size, mtime) (flags, size, mtime)
} }
}; };
on_disk_nodes.push(match node { on_disk_nodes.push(match node {
NodeRef::InMemory(path, node) => { NodeRef::InMemory(path, node) => {
let (flags, size, mtime) = match &node.data { let (flags, size, mtime) = match &node.data {
dirstate_map::NodeData::Entry(entry) => { dirstate_map::NodeData::Entry(entry) => {
Node::from_dirstate_entry(entry) Node::from_dirstate_entry(entry)
} }
dirstate_map::NodeData::CachedDirectory { mtime } => { dirstate_map::NodeData::CachedDirectory { mtime } => (
(Flags::HAS_MTIME, 0.into(), (*mtime).into()) Flags::HAS_DIRECTORY_MTIME,
} 0.into(),
(*mtime).into(),
),
dirstate_map::NodeData::None => ( dirstate_map::NodeData::None => (
Flags::empty(), Flags::empty(),
0.into(), 0.into(),
PackedTruncatedTimestamp::null(), PackedTruncatedTimestamp::null(),
), ),
}; };
Node { Node {
children, children,