Support removed values in extract.

```
name                                old cpu/op   new cpu/op   delta
BM_DisjointChains/1/1               1.73µs ± 2%  1.43µs ± 3%  -17.49%  (p=0.008 n=5+5)
BM_DisjointChains/1/1000            25.2µs ± 1%  25.0µs ± 3%     ~     (p=0.222 n=5+5)
BM_DisjointChains/1/977k            28.3ms ±20%  24.7ms ± 2%  -12.57%  (p=0.008 n=5+5)
BM_DisjointChains/2/1               3.08µs ± 4%  2.31µs ± 2%  -24.87%  (p=0.008 n=5+5)
BM_DisjointChains/2/1000            44.3µs ±13%  41.6µs ± 3%     ~     (p=0.056 n=5+5)
BM_DisjointChains/2/977k            49.7ms ±15%  51.7ms ±17%     ~     (p=0.841 n=5+5)
BM_DisjointChains/1000/1            1.36ms ± 2%  0.99ms ± 3%  -27.01%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1000         18.5ms ± 2%  18.0ms ± 2%     ~     (p=0.056 n=5+5)
BM_DisjointChains/977k/1             2.60s ± 1%   2.21s ± 6%  -15.10%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1        2.49µs ± 3%  2.14µs ± 3%  -14.16%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1000     43.4µs ± 2%  42.5µs ± 1%   -2.01%  (p=0.016 n=5+5)
BM_DisjointChainsObjects/1/977k     51.1ms ±14%  50.0ms ±18%     ~     (p=0.690 n=5+5)
BM_DisjointChainsObjects/2/1        4.49µs ± 1%  3.75µs ± 3%  -16.39%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/1000     78.3µs ± 2%  77.4µs ± 1%     ~     (p=0.151 n=5+5)
BM_DisjointChainsObjects/2/977k      103ms ±13%   104ms ± 7%     ~     (p=1.000 n=5+5)
BM_DisjointChainsObjects/1000/1     2.04ms ± 4%  1.67ms ± 3%  -18.21%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1000/1000  41.0ms ±11%  38.8ms ± 2%     ~     (p=0.310 n=5+5)
BM_DisjointChainsObjects/977k/1      3.40s ± 2%   3.05s ± 3%  -10.34%  (p=0.008 n=5+5)
BM_DAG/2/10/100/1000                 252µs ± 1%   247µs ± 2%     ~     (p=0.095 n=5+5)
BM_DAG/2/100/100/1000               2.48ms ± 1%  2.41ms ± 1%   -2.87%  (p=0.008 n=5+5)
BM_DAG/2/100/100/10                  229µs ± 3%   194µs ± 3%  -15.24%  (p=0.008 n=5+5)
BM_DAG/20/10/100/10                  239µs ± 2%   199µs ± 1%  -16.81%  (p=0.008 n=5+5)
BM_DAG/20/100/100/10                2.58ms ± 1%  2.32ms ±13%     ~     (p=0.151 n=5+5)
BM_DAG/20/100/10/10                 11.0ms ± 3%  10.2ms ± 2%   -7.22%  (p=0.008 n=5+5)
BM_DAGObjects/2/10/100/1000          444µs ± 1%   442µs ± 1%     ~     (p=0.310 n=5+5)
BM_DAGObjects/2/100/100/1000        4.27ms ± 1%  4.26ms ± 4%     ~     (p=1.000 n=5+5)
BM_DAGObjects/2/100/100/10           323µs ± 2%   283µs ± 3%  -12.19%  (p=0.008 n=5+5)
BM_DAGObjects/20/10/100/10           344µs ± 3%   305µs ± 3%  -11.40%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/100/10         3.80ms ± 2%  3.43ms ± 4%   -9.65%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/10/10          16.1ms ± 2%  15.6ms ± 3%   -3.41%  (p=0.016 n=5+5)

name                                old time/op             new time/op             delta
BM_DisjointChains/1/1               1.74µs ± 2%             1.44µs ± 3%  -17.38%  (p=0.008 n=5+5)
BM_DisjointChains/1/1000            25.3µs ± 1%             25.0µs ± 3%     ~     (p=0.222 n=5+5)
BM_DisjointChains/1/977k            28.4ms ±20%             24.8ms ± 2%  -12.57%  (p=0.008 n=5+5)
BM_DisjointChains/2/1               3.09µs ± 4%             2.32µs ± 2%  -24.88%  (p=0.008 n=5+5)
BM_DisjointChains/2/1000            44.3µs ±14%             41.7µs ± 3%     ~     (p=0.056 n=5+5)
BM_DisjointChains/2/977k            50.3ms ±18%             52.2ms ±18%     ~     (p=0.841 n=5+5)
BM_DisjointChains/1000/1            1.36ms ± 2%             0.99ms ± 3%  -27.02%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1000         18.6ms ± 2%             18.1ms ± 2%     ~     (p=0.056 n=5+5)
BM_DisjointChains/977k/1             2.61s ± 1%              2.22s ± 6%  -15.10%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1        2.50µs ± 3%             2.14µs ± 3%  -14.16%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1000     43.5µs ± 2%             42.7µs ± 1%   -1.99%  (p=0.016 n=5+5)
BM_DisjointChainsObjects/1/977k     51.2ms ±14%             50.2ms ±18%     ~     (p=0.690 n=5+5)
BM_DisjointChainsObjects/2/1        4.50µs ± 1%             3.76µs ± 3%  -16.42%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/1000     78.5µs ± 2%             77.6µs ± 1%     ~     (p=0.095 n=5+5)
BM_DisjointChainsObjects/2/977k      103ms ±13%              104ms ± 7%     ~     (p=1.000 n=5+5)
BM_DisjointChainsObjects/1000/1     2.05ms ± 5%             1.67ms ± 3%  -18.25%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1000/1000  41.2ms ±11%             39.0ms ± 2%     ~     (p=0.222 n=5+5)
BM_DisjointChainsObjects/977k/1      3.41s ± 2%              3.06s ± 3%  -10.31%  (p=0.008 n=5+5)
BM_DAG/2/10/100/1000                 252µs ± 1%              247µs ± 3%     ~     (p=0.151 n=5+5)
BM_DAG/2/100/100/1000               2.49ms ± 1%             2.41ms ± 1%   -2.90%  (p=0.008 n=5+5)
BM_DAG/2/100/100/10                  230µs ± 3%              195µs ± 3%  -15.25%  (p=0.008 n=5+5)
BM_DAG/20/10/100/10                  239µs ± 2%              199µs ± 1%  -16.81%  (p=0.008 n=5+5)
BM_DAG/20/100/100/10                2.59ms ± 2%             2.33ms ±13%     ~     (p=0.151 n=5+5)
BM_DAG/20/100/10/10                 11.0ms ± 3%             10.2ms ± 2%   -7.26%  (p=0.008 n=5+5)
BM_DAGObjects/2/10/100/1000          446µs ± 1%              443µs ± 1%     ~     (p=0.310 n=5+5)
BM_DAGObjects/2/100/100/1000        4.29ms ± 1%             4.28ms ± 4%     ~     (p=1.000 n=5+5)
BM_DAGObjects/2/100/100/10           324µs ± 2%              284µs ± 3%  -12.18%  (p=0.008 n=5+5)
BM_DAGObjects/20/10/100/10           345µs ± 3%              306µs ± 3%  -11.37%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/100/10         3.81ms ± 3%             3.45ms ± 4%   -9.64%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/10/10          16.2ms ± 2%             15.6ms ± 2%   -3.41%  (p=0.016 n=5+5)

name                                old INSTRUCTIONS/op     new INSTRUCTIONS/op     delta
BM_DisjointChains/1/1                13.7k ± 0%              11.5k ± 0%  -16.11%  (p=0.008 n=5+5)
BM_DisjointChains/1/1000              238k ± 1%               242k ± 0%   +1.29%  (p=0.008 n=5+5)
BM_DisjointChains/1/977k              223M ± 0%               229M ± 0%   +2.49%  (p=0.008 n=5+5)
BM_DisjointChains/2/1                23.1k ± 0%              18.5k ± 0%  -19.89%  (p=0.016 n=4+5)
BM_DisjointChains/2/1000              402k ± 1%               409k ± 0%   +1.78%  (p=0.008 n=5+5)
BM_DisjointChains/2/977k              376M ± 0%               387M ± 0%   +3.02%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1             9.66M ± 1%              7.21M ± 1%  -25.40%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1000           166M ± 0%               170M ± 0%   +2.64%  (p=0.016 n=5+4)
BM_DisjointChains/977k/1             9.85G ± 0%              7.46G ± 1%  -24.23%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1         18.3k ± 0%              16.2k ± 0%  -11.62%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1000       423k ± 1%               426k ± 0%     ~     (p=0.056 n=5+5)
BM_DisjointChainsObjects/1/977k       403M ± 0%               408M ± 0%   +1.42%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/1         32.5k ± 0%              28.1k ± 0%  -13.67%  (p=0.016 n=4+5)
BM_DisjointChainsObjects/2/1000       771k ± 0%               784k ± 0%   +1.68%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/977k       735M ± 0%               752M ± 0%   +2.26%  (p=0.016 n=4+5)
BM_DisjointChainsObjects/1000/1      14.1M ± 0%              11.9M ± 1%  -15.69%  (p=0.016 n=4+5)
BM_DisjointChainsObjects/1000/1000    354M ± 0%               363M ± 0%   +2.72%  (p=0.016 n=4+5)
BM_DisjointChainsObjects/977k/1      14.5G ± 1%              12.1G ± 0%  -16.77%  (p=0.008 n=5+5)
BM_DAG/2/10/100/1000                 2.58M ± 1%              2.64M ± 0%   +2.60%  (p=0.008 n=5+5)
BM_DAG/2/100/100/1000                24.5M ± 1%              25.3M ± 0%   +3.06%  (p=0.008 n=5+5)
BM_DAG/2/100/100/10                  1.78M ± 0%              1.52M ± 1%  -14.44%  (p=0.008 n=5+5)
BM_DAG/20/10/100/10                  1.82M ± 1%              1.55M ± 0%  -14.79%  (p=0.008 n=5+5)
BM_DAG/20/100/100/10                 18.6M ± 0%              16.0M ± 0%  -14.17%  (p=0.008 n=5+5)
BM_DAG/20/100/10/10                  77.8M ± 1%              75.0M ± 1%   -3.55%  (p=0.008 n=5+5)
BM_DAGObjects/2/10/100/1000          4.45M ± 0%              4.54M ± 0%   +2.10%  (p=0.016 n=4+5)
BM_DAGObjects/2/100/100/1000         41.6M ± 1%              42.4M ± 0%   +1.88%  (p=0.008 n=5+5)
BM_DAGObjects/2/100/100/10           2.41M ± 1%              2.16M ± 1%  -10.60%  (p=0.008 n=5+5)
BM_DAGObjects/20/10/100/10           2.54M ± 1%              2.25M ± 0%  -11.42%  (p=0.016 n=5+4)
BM_DAGObjects/20/100/100/10          25.7M ± 0%              23.2M ± 1%   -9.55%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/10/10            115M ± 0%               113M ± 1%   -2.23%  (p=0.008 n=5+5)

name                                old CYCLES/op           new CYCLES/op           delta
BM_DisjointChains/1/1                5.61k ± 2%              4.60k ± 0%  -18.01%  (p=0.008 n=5+5)
BM_DisjointChains/1/1000             81.9k ± 1%              80.7k ± 1%   -1.51%  (p=0.008 n=5+5)
BM_DisjointChains/1/977k             82.9M ± 3%              81.4M ± 1%     ~     (p=0.222 n=5+5)
BM_DisjointChains/2/1                9.83k ± 3%              7.51k ± 1%  -23.59%  (p=0.008 n=5+5)
BM_DisjointChains/2/1000              137k ± 1%               135k ± 1%   -1.42%  (p=0.032 n=5+5)
BM_DisjointChains/2/977k              142M ± 2%               138M ± 2%     ~     (p=0.056 n=5+5)
BM_DisjointChains/1000/1             4.40M ± 1%              3.25M ± 1%  -26.10%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1000          59.5M ± 1%              59.0M ± 1%     ~     (p=0.222 n=5+5)
BM_DisjointChains/977k/1             8.05G ± 2%              6.93G ± 6%  -13.91%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1         8.02k ± 0%              6.96k ± 0%  -13.24%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1000       140k ± 1%               140k ± 0%     ~     (p=0.841 n=5+5)
BM_DisjointChainsObjects/1/977k       147M ± 2%               147M ± 1%     ~     (p=1.000 n=5+5)
BM_DisjointChainsObjects/2/1         14.4k ± 2%              12.3k ± 1%  -14.61%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/1000       253k ± 1%               254k ± 0%   +0.67%  (p=0.016 n=5+5)
BM_DisjointChainsObjects/2/977k       274M ± 2%               272M ± 1%     ~     (p=0.421 n=5+5)
BM_DisjointChainsObjects/1000/1      6.59M ± 4%              5.44M ± 1%  -17.42%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1000/1000    127M ± 2%               127M ± 0%     ~     (p=0.421 n=5+5)
BM_DisjointChainsObjects/977k/1      10.7G ± 1%               9.6G ± 4%  -10.38%  (p=0.008 n=5+5)
BM_DAG/2/10/100/1000                  815k ± 2%               805k ± 1%     ~     (p=0.095 n=5+5)
BM_DAG/2/100/100/1000                8.02M ± 1%              7.92M ± 2%     ~     (p=0.095 n=5+5)
BM_DAG/2/100/100/10                   735k ± 0%               634k ± 1%  -13.79%  (p=0.008 n=5+5)
BM_DAG/20/10/100/10                   763k ± 1%               651k ± 1%  -14.75%  (p=0.008 n=5+5)
BM_DAG/20/100/100/10                 8.33M ± 0%              7.23M ± 2%  -13.12%  (p=0.008 n=5+5)
BM_DAG/20/100/10/10                  35.1M ± 1%              33.6M ± 1%   -4.18%  (p=0.008 n=5+5)
BM_DAGObjects/2/10/100/1000          1.44M ± 1%              1.45M ± 0%   +0.81%  (p=0.032 n=5+5)
BM_DAGObjects/2/100/100/1000         13.7M ± 1%              13.8M ± 0%     ~     (p=0.095 n=5+5)
BM_DAGObjects/2/100/100/10           1.04M ± 1%              0.93M ± 2%  -10.53%  (p=0.008 n=5+5)
BM_DAGObjects/20/10/100/10           1.11M ± 2%              0.98M ± 1%  -11.66%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/100/10          12.2M ± 1%              11.1M ± 2%   -8.58%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/10/10           52.2M ± 0%              51.1M ± 1%   -2.20%  (p=0.008 n=5+5)

name                                old allocs/op           new allocs/op           delta
BM_DisjointChains/1/1                 30.0 ± 0%               27.0 ± 0%  -10.00%  (p=0.008 n=5+5)
BM_DisjointChains/1/1000              34.0 ± 0%               33.0 ± 0%   -2.94%  (p=0.008 n=5+5)
BM_DisjointChains/1/977k              37.0 ± 0%               36.0 ± 0%   -2.70%  (p=0.008 n=5+5)
BM_DisjointChains/2/1                 50.0 ± 0%               42.0 ± 0%  -16.00%  (p=0.008 n=5+5)
BM_DisjointChains/2/1000              56.0 ± 0%               54.0 ± 0%   -3.57%  (p=0.008 n=5+5)
BM_DisjointChains/2/977k              61.0 ± 0%               59.0 ± 0%     ~     (p=0.079 n=4+5)
BM_DisjointChains/1000/1             18.1k ± 0%              13.1k ± 0%  -27.69%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1000          20.1k ± 0%              19.1k ± 0%   -4.99%  (p=0.008 n=5+5)
BM_DisjointChains/977k/1             18.0M ± 0%              13.0M ± 0%  -27.78%  (p=0.016 n=4+5)
BM_DisjointChainsObjects/1/1          52.0 ± 0%               49.0 ± 0%   -5.77%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1/1000       57.0 ± 0%               56.0 ± 0%   -1.75%  (p=0.000 n=5+4)
BM_DisjointChainsObjects/1/977k       62.0 ± 0%               61.0 ± 0%   -1.61%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/1          92.0 ± 0%               84.0 ± 0%   -8.70%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/1000        100 ± 0%                 98 ± 0%   -2.00%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/977k        109 ± 0%                107 ± 0%   -1.83%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1000/1      37.1k ± 0%              32.1k ± 0%  -13.49%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1000/1000   41.0k ± 0%              40.0k ± 0%   -2.44%  (p=0.029 n=4+4)
BM_DisjointChainsObjects/977k/1      37.0M ± 0%              32.0M ± 0%  -13.51%  (p=0.008 n=5+5)
BM_DAG/2/10/100/1000                   353 ± 0%                333 ± 0%   -5.67%  (p=0.008 n=5+5)
BM_DAG/2/100/100/1000                3.24k ± 0%              3.04k ± 0%   -6.17%  (p=0.008 n=5+5)
BM_DAG/2/100/100/10                  3.04k ± 0%              2.84k ± 0%   -6.57%  (p=0.008 n=5+5)
BM_DAG/20/10/100/10                  3.17k ± 0%              2.97k ± 0%   -6.31%  (p=0.008 n=5+5)
BM_DAG/20/100/100/10                 30.2k ± 0%              28.2k ± 0%   -6.61%  (p=0.008 n=5+5)
BM_DAG/20/100/10/10                   143k ± 1%               117k ± 1%  -17.95%  (p=0.008 n=5+5)
BM_DAGObjects/2/10/100/1000            559 ± 0%                539 ± 0%   -3.58%  (p=0.008 n=5+5)
BM_DAGObjects/2/100/100/1000         5.07k ± 0%              4.87k ± 0%     ~     (p=0.079 n=4+5)
BM_DAGObjects/2/100/100/10           4.87k ± 0%              4.67k ± 0%   -4.11%  (p=0.008 n=5+5)
BM_DAGObjects/20/10/100/10           5.21k ± 0%              5.01k ± 0%   -3.84%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/100/10          48.5k ± 0%              46.5k ± 0%   -4.13%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/10/10            309k ± 0%               285k ± 1%   -7.92%  (p=0.008 n=5+5)

name                                old peak-mem(Bytes)/op  new peak-mem(Bytes)/op  delta
BM_DisjointChains/1/1                6.44k ± 0%              5.93k ± 0%   -7.89%  (p=0.008 n=5+5)
BM_DisjointChains/1/1000             57.2k ± 0%              56.8k ± 0%   -0.81%  (p=0.008 n=5+5)
BM_DisjointChains/1/977k             50.7M ± 0%              50.7M ± 0%   -0.00%  (p=0.008 n=5+5)
BM_DisjointChains/2/1                7.30k ± 0%              6.62k ± 0%     ~     (p=0.079 n=4+5)
BM_DisjointChains/2/1000             91.5k ± 0%              92.2k ± 0%   +0.80%  (p=0.029 n=4+4)
BM_DisjointChains/2/977k             84.0M ± 0%              85.1M ± 0%   +1.35%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1              608k ± 0%               608k ± 0%   -0.13%  (p=0.008 n=5+5)
BM_DisjointChains/1000/1000          18.3M ± 0%              18.3M ± 0%   +0.00%  (p=0.016 n=4+5)
BM_DisjointChains/977k/1              612M ± 0%               612M ± 0%   -0.00%  (p=0.032 n=4+5)
BM_DisjointChainsObjects/1/1         7.61k ± 0%              7.11k ± 0%     ~     (p=0.079 n=4+5)
BM_DisjointChainsObjects/1/1000       110k ± 0%               109k ± 0%   -0.42%  (p=0.000 n=5+4)
BM_DisjointChainsObjects/1/977k       102M ± 0%               102M ± 0%   -0.00%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/1         8.27k ± 0%              7.76k ± 0%   -6.15%  (p=0.000 n=5+4)
BM_DisjointChainsObjects/2/1000       162k ± 0%               162k ± 0%   -0.18%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/2/977k       154M ± 0%               154M ± 0%   +0.08%  (p=0.008 n=5+5)
BM_DisjointChainsObjects/1000/1       609k ± 0%               609k ± 0%     ~     (p=0.667 n=5+5)
BM_DisjointChainsObjects/1000/1000   36.9M ± 0%              36.9M ± 0%   -0.00%  (p=0.016 n=5+4)
BM_DisjointChainsObjects/977k/1       612M ± 0%               612M ± 0%   -0.00%  (p=0.016 n=4+5)
BM_DAG/2/10/100/1000                  417k ± 0%               419k ± 0%   +0.46%  (p=0.016 n=5+4)
BM_DAG/2/100/100/1000                3.50M ± 0%              3.50M ± 0%   +0.05%  (p=0.016 n=4+5)
BM_DAG/2/100/100/10                   185k ± 0%               185k ± 0%   -0.20%  (p=0.000 n=5+4)
BM_DAG/20/10/100/10                   200k ± 0%               199k ± 0%   -0.19%  (p=0.000 n=4+5)
BM_DAG/20/100/100/10                 1.95M ± 0%              1.95M ± 0%   -0.02%  (p=0.029 n=4+4)
BM_DAG/20/100/10/10                  1.24M ± 1%              1.46M ± 1%  +17.52%  (p=0.008 n=5+5)
BM_DAGObjects/2/10/100/1000           519k ± 0%               519k ± 0%   -0.02%  (p=0.008 n=5+5)
BM_DAGObjects/2/100/100/1000         3.90M ± 0%              3.90M ± 0%     ~     (p=0.079 n=4+5)
BM_DAGObjects/2/100/100/10            296k ± 0%               296k ± 0%   -0.13%  (p=0.008 n=5+5)
BM_DAGObjects/20/10/100/10            321k ± 0%               321k ± 0%   -0.12%  (p=0.008 n=5+5)
BM_DAGObjects/20/100/100/10          3.30M ± 0%              3.30M ± 0%   +0.00%  (p=0.016 n=4+5)
BM_DAGObjects/20/100/10/10           2.31M ± 1%              2.81M ± 0%  +21.76%  (p=0.008 n=5+5)
```

PiperOrigin-RevId: 718016652
Change-Id: I92507a140cc76a359a4186f53ebdde9a88c39f95

Author: goldvitaly

koladata/internal/BUILD

@@ -566,6 +566,7 @@ cc_test(
         ":dtype",
         ":object_id",
         ":schema_utils",
+        ":types_buffer",
         ":uuid_object",
         "//koladata/internal/testing:matchers",
         "//koladata/s11n",

koladata/internal/data_bag.cc

@@ -34,7 +34,6 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/hash/hash.h"
 #include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -445,9 +444,9 @@ SparseSource& DataBagImpl::GetMutableSmallAllocSource(absl::string_view attr) {
   return small_alloc_sources_[attr];
 }
 
-absl::StatusOr<DataSliceImpl> DataBagImpl::GetAttr(
+absl::StatusOr<DataSliceImpl> DataBagImpl::GetAttrImpl(
     const DataSliceImpl& objects, absl::string_view attr,
-    FallbackSpan fallbacks) const {
+    FallbackSpan fallbacks, bool with_removed) const {
   if (objects.is_empty_and_unknown()) {
     return DataSliceImpl::CreateEmptyAndUnknownType(objects.size());
   }
@@ -468,6 +467,9 @@ absl::StatusOr<DataSliceImpl> DataBagImpl::GetAttr(
   };
 
   std::optional<SliceBuilder> bldr;
+  if (with_removed) {
+    bldr.emplace(objs.size());
+  }
   for (const DataBagImpl* db = this; db != nullptr; db = next_fallback()) {
     ConstDenseSourceArray dense_sources;
     ConstSparseSourceArray sparse_sources;
@@ -522,6 +524,19 @@ absl::StatusOr<DataSliceImpl> DataBagImpl::GetAttr(
   }
 }
 
+absl::StatusOr<DataSliceImpl> DataBagImpl::GetAttr(
+    const DataSliceImpl& objects, absl::string_view attr,
+    FallbackSpan fallbacks) const {
+  return GetAttrImpl(objects, attr, fallbacks, /*with_removed=*/false);
+}
+
+
+absl::StatusOr<DataSliceImpl> DataBagImpl::GetAttrWithRemoved(
+    const DataSliceImpl& objects, absl::string_view attr,
+    FallbackSpan fallbacks) const {
+  return GetAttrImpl(objects, attr, fallbacks, /*with_removed=*/true);
+}
+
 absl::StatusOr<DataItem> DataBagImpl::GetAttr(const DataItem& object,
                                               absl::string_view attr,
                                               FallbackSpan fallbacks) const {

koladata/internal/data_bag.h

@@ -163,7 +163,7 @@ class DataBagImpl : public arolla::RefcountedBase {
   bool IsPristine() const;
 
   // Returns DataSliceImpl with attribute for every object.
-  // Missing values are looked up in the fallback databags.
+  // Missing (not removed) values are looked up in the fallback databags.
   absl::StatusOr<DataSliceImpl> GetAttr(
       const DataSliceImpl& objects,
       absl::string_view attr,
@@ -174,6 +174,15 @@ class DataBagImpl : public arolla::RefcountedBase {
       absl::string_view attr,
       FallbackSpan fallbacks = {}) const;
 
+  // Returns DataSliceImpl with attribute for every object.
+  // Resulting DataSliceImpl always contains types_buffer to distinguish
+  // removed and unset values.
+  // Missing (not removed) values are looked up in the fallback databags.
+  absl::StatusOr<DataSliceImpl> GetAttrWithRemoved(
+      const DataSliceImpl& objects,
+      absl::string_view attr,
+      FallbackSpan fallbacks = {}) const;
+
   // Gets __schema__ attribute for objects and returns an Error if DataSlice has
   // primitives or objects do not have __schema__ attribute.
   absl::StatusOr<DataItem> GetObjSchemaAttr(const DataItem& item,
@@ -654,6 +663,12 @@ class DataBagImpl : public arolla::RefcountedBase {
   std::optional<DataItem> LookupAttrInDataSourcesMap(
       ObjectId object_id, absl::string_view attr) const;
 
+  absl::StatusOr<DataSliceImpl> GetAttrImpl(
+      const DataSliceImpl& objects,
+      absl::string_view attr,
+      FallbackSpan fallbacks,
+      bool with_removed) const;
+
   template <bool kReturnValues>
   absl::StatusOr<std::pair<DataSliceImpl, arolla::DenseArrayEdge>>
   GetDictKeysOrValues(const DataSliceImpl& dicts, FallbackSpan fallbacks) const;

koladata/internal/data_bag_test.cc

@@ -37,6 +37,7 @@
 #include "koladata/internal/schema_utils.h"
 #include "koladata/internal/slice_builder.h"
 #include "koladata/internal/testing/matchers.h"
+#include "koladata/internal/types_buffer.h"
 #include "koladata/internal/uuid_object.h"
 #include "arolla/dense_array/dense_array.h"
 #include "arolla/dense_array/qtype/types.h"
@@ -159,6 +160,49 @@ TEST(DataBagTest, SetGet) {
               ElementsAreArray(ds_a.values<ObjectId>()));
 }
 
+TEST(DataBagTest, GetAttrWithRemoved) {
+  for (int64_t size : {1, 3, 7, 13, 1023}) {
+    SCOPED_TRACE(absl::StrCat("size: ", size));
+    auto db = DataBagImpl::CreateEmptyDatabag();
+    AllocationId alloc = Allocate(size);
+    std::vector<DataItem> objects;
+    for (int64_t i = 0; i < size; ++i) {
+      objects.push_back(i % 3 == 2 ? DataItem()
+                                   : DataItem(alloc.ObjectByOffset(i)));
+    }
+    auto ds = DataSliceImpl::Create(objects);
+    std::vector<DataItem> items;
+    for (int64_t i = 0; i < size; ++i) {
+      items.push_back(i % 2 == 1 ? DataItem(i) : DataItem());
+    }
+    auto ds_a = DataSliceImpl::Create(items);
+
+    ASSERT_OK(db->SetAttr(ds, "a", ds_a));
+
+    auto all_objects = DataSliceImpl::ObjectsFromAllocation(alloc, size);
+    ASSERT_OK_AND_ASSIGN(auto ds_a_get,
+                         db->GetAttrWithRemoved(all_objects, "a"));
+
+    EXPECT_EQ(ds_a_get.size(), size);
+    EXPECT_THAT(ds_a_get.allocation_ids(), IsEmpty());
+    EXPECT_EQ(ds_a_get.types_buffer().size(), size);
+    EXPECT_EQ(ds_a_get.is_empty_and_unknown(), size == 1);
+    for (int64_t i = 0; i < size; ++i) {
+      bool is_set = i % 3 != 2;
+      bool is_removed = i % 2 == 0;
+      ASSERT_EQ(ds_a_get[i], is_set && !is_removed ? DataItem(i) : DataItem())
+          << i;
+      if (size != 1) {
+        auto expected_typeidx = is_set
+                                    ? (is_removed ? TypesBuffer::kRemoved : 0)
+                                    : TypesBuffer::kUnset;
+        ASSERT_EQ(ds_a_get.types_buffer().id_to_typeidx[i], expected_typeidx)
+            << i;
+      }
+    }
+  }
+}
+
 TEST(DataBagTest, GetObjSchemaAttr) {
   constexpr int64_t kSize = 13;
   auto db = DataBagImpl::CreateEmptyDatabag();

koladata/internal/op_utils/BUILD

@@ -128,6 +128,7 @@ cc_library(
         "//koladata/internal:dtype",
         "//koladata/internal:object_id",
         "//koladata/internal:schema_utils",
+        "//koladata/internal:types_buffer",
         "//koladata/internal:uuid_object",
         "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/log:check",

koladata/internal/op_utils/extract.cc

@@ -42,7 +42,9 @@
 #include "koladata/internal/op_utils/presence_or.h"
 #include "koladata/internal/schema_utils.h"
 #include "koladata/internal/slice_builder.h"
+#include "koladata/internal/types_buffer.h"
 #include "koladata/internal/uuid_object.h"
+#include "arolla/dense_array/bitmap.h"
 #include "arolla/dense_array/dense_array.h"
 #include "arolla/dense_array/ops/dense_ops.h"
 #include "arolla/memory/optional_value.h"
@@ -234,23 +236,30 @@ class CopyingProcessor {
   absl::Status ProcessAttribute(const QueuedSlice& slice,
                                 const std::string_view attr_name,
                                 const DataItem& attr_schema) {
-    const auto& ds = slice.slice;
+    auto ds = slice.slice;
     DataSliceImpl old_ds;
     if (is_shallow_clone_) {
       ASSIGN_OR_RETURN(old_ds, objects_tracker_->GetAttr(ds, kMappingAttrName));
     } else {
       old_ds = ds;
     }
-    ASSIGN_OR_RETURN(auto attr_ds,
-                     databag_.GetAttr(old_ds, attr_name, fallbacks_));
-    // TODO: Extract and respect removed values.
-    ASSIGN_OR_RETURN(auto has_attr_ds, HasOp()(attr_ds));
-    ASSIGN_OR_RETURN(auto filtered_ds, PresenceAndOp()(ds, has_attr_ds));
+    ASSIGN_OR_RETURN(auto attr_ds, databag_.GetAttrWithRemoved(
+                                       old_ds, attr_name, fallbacks_));
+    if (attr_ds.types_buffer().size() != 0) {
+      auto set_mask =
+          attr_ds.types_buffer().ToInvertedBitmap(TypesBuffer::kUnset);
+      if (!arolla::bitmap::AreAllBitsSet(set_mask.begin(), ds.size())) {
+        const auto& objects_array = ds.values<ObjectId>();
+        ds = DataSliceImpl::CreateWithAllocIds(
+            ds.allocation_ids(),
+            ObjectIdArray{objects_array.values, std::move(set_mask)});
+      }
+    }
     if (max_depth_ == -1 || slice.depth < max_depth_) {
-      RETURN_IF_ERROR(new_databag_->SetAttr(filtered_ds, attr_name, attr_ds));
+      RETURN_IF_ERROR(new_databag_->SetAttr(ds, attr_name, attr_ds));
     }
-    RETURN_IF_ERROR(Visit(
-        {std::move(attr_ds), attr_schema, slice.schema_source, slice.depth}));
+    RETURN_IF_ERROR(
+        Visit({std::move(attr_ds), attr_schema, slice.schema_source}));
     return absl::OkStatus();
   }
 

koladata/internal/op_utils/extract_test.cc

@@ -47,15 +47,17 @@
 namespace koladata::internal {
 namespace {
 
+using ::absl_testing::IsOkAndHolds;
 using ::absl_testing::StatusIs;
 using ::testing::IsEmpty;
 using ::testing::UnorderedElementsAre;
 
 using ::arolla::CreateDenseArray;
 using ::koladata::internal::testing::DataBagEqual;
+using ::koladata::internal::testing::IsEquivalentTo;
 
-using TriplesT = std::vector<
-    std::pair<DataItem, std::vector<std::pair<std::string_view, DataItem>>>>;
+using AttrsT = std::vector<std::pair<std::string_view, DataItem>>;
+using TriplesT = std::vector<std::pair<DataItem, AttrsT>>;
 
 DataItem AllocateSchema() {
   return DataItem(internal::AllocateExplicitSchema());
@@ -1019,6 +1021,103 @@ TEST_P(ExtractTest, DataSliceEntity) {
   EXPECT_THAT(result_db, DataBagEqual(*expected_db));
 }
 
+TEST_P(ExtractTest, DataSliceEntityRemovedValues) {
+  for (int64_t size : {1, 3, 17, 1034}) {
+    auto obj_ids = AllocateEmptyObjects(size);
+    auto int_dtype = DataItem(schema::kInt32);
+    auto schema = AllocateSchema();
+
+    TriplesT schema_triples = {{schema, {{"x", int_dtype}, {"y", int_dtype}}}};
+    TriplesT data_triples;
+    TriplesT data_triples_fallback;
+    TriplesT data_triples_expected;
+    for (int64_t i = 0; i < size; ++i) {
+      if (i % 3 == 0) {
+        data_triples.emplace_back(obj_ids[i], AttrsT{{"x", DataItem()}});
+        data_triples_fallback.emplace_back(obj_ids[i],
+                                           AttrsT{{"x", DataItem(i * 2 + 97)}});
+        data_triples_expected.emplace_back(obj_ids[i],
+                                           AttrsT{{"x", DataItem()}});
+      } else if (i % 3 == 1) {
+        data_triples.emplace_back(obj_ids[i], AttrsT{{"x", DataItem(i * 2)}});
+        data_triples_fallback.emplace_back(obj_ids[i],
+                                           AttrsT{{"x", DataItem(i * 2 + 19)}});
+        data_triples_expected.emplace_back(obj_ids[i],
+                                           AttrsT{{"x", DataItem(i * 2)}});
+      } else {
+        data_triples_fallback.emplace_back(obj_ids[i],
+                                           AttrsT{{"x", DataItem(i * 2 - 13)}});
+        data_triples_expected.emplace_back(obj_ids[i],
+                                           AttrsT{{"x", DataItem(i * 2 - 13)}});
+      }
+    }
+
+    auto db = DataBagImpl::CreateEmptyDatabag();
+    SetSchemaTriples(*db, schema_triples);
+    SetDataTriples(*db, data_triples);
+    auto fb = DataBagImpl::CreateEmptyDatabag();
+    SetSchemaTriples(*fb, schema_triples);
+    SetDataTriples(*fb, data_triples_fallback);
+    SetSchemaTriples(*db, GenNoiseSchemaTriples());
+    SetDataTriples(*db, GenNoiseDataTriples());
+
+    auto expected_db = DataBagImpl::CreateEmptyDatabag();
+    SetSchemaTriples(*expected_db, schema_triples);
+    SetDataTriples(*expected_db, data_triples_expected);
+
+    auto result_db = DataBagImpl::CreateEmptyDatabag();
+    ASSERT_OK(ExtractOp(result_db.get())(obj_ids, schema, *GetMainDb(db),
+                                         {GetFallbackDb(db).get()}, nullptr,
+                                         {}));
+
+    ASSERT_NE(result_db.get(), db.get());
+    {
+      ASSERT_OK_AND_ASSIGN(auto expected_x, expected_db->GetAttr(obj_ids, "x"));
+      EXPECT_THAT(result_db->GetAttr(obj_ids, "x", {fb.get()}),
+                  IsOkAndHolds(IsEquivalentTo(expected_x)));
+    }
+  }
+}
+
+TEST_P(ExtractTest, DataSliceEntityAllUnset) {
+  for (int64_t size : {1, 3, 17, 1034}) {
+    auto obj_ids = AllocateEmptyObjects(size);
+    auto int_dtype = DataItem(schema::kInt32);
+    auto schema = AllocateSchema();
+
+    TriplesT schema_triples = {{schema, {{"x", int_dtype}, {"y", int_dtype}}}};
+    TriplesT data_triples;
+    for (int64_t i = 0; i < size; ++i) {
+      data_triples.emplace_back(obj_ids[i],
+                                         AttrsT{{"x", DataItem(i)}});
+    }
+
+    auto db = DataBagImpl::CreateEmptyDatabag();
+    SetSchemaTriples(*db, schema_triples);
+    auto fb = DataBagImpl::CreateEmptyDatabag();
+    SetSchemaTriples(*fb, schema_triples);
+    SetDataTriples(*fb, data_triples);
+    SetSchemaTriples(*db, GenNoiseSchemaTriples());
+    SetDataTriples(*db, GenNoiseDataTriples());
+
+    auto expected_db = DataBagImpl::CreateEmptyDatabag();
+    SetSchemaTriples(*expected_db, schema_triples);
+    SetDataTriples(*expected_db, data_triples);
+
+    auto result_db = DataBagImpl::CreateEmptyDatabag();
+    ASSERT_OK(ExtractOp(result_db.get())(obj_ids, schema, *GetMainDb(db),
+                                         {GetFallbackDb(db).get()}, nullptr,
+                                         {}));
+
+    ASSERT_NE(result_db.get(), db.get());
+    {
+      ASSERT_OK_AND_ASSIGN(auto expected_x, expected_db->GetAttr(obj_ids, "x"));
+      EXPECT_THAT(result_db->GetAttr(obj_ids, "x", {fb.get()}),
+                  IsOkAndHolds(IsEquivalentTo(expected_x)));
+    }
+  }
+}
+
 TEST_P(ExtractTest, MaxDepthSliceOfListsSingleAllocation) {
   const DataItem obj_dtype = DataItem(schema::kObject);
   const DataItem int_dtype = DataItem(schema::kInt32);