Full Code of timescale/timescaledb-toolkit for AI

gitextract_o1olp053/

├── .cargo/
│   └── config
├── .dockerignore
├── .git-blame-ignore-revs
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug-report.md
│   │   ├── feature-request.md
│   │   ├── feature-stabilization.md
│   │   └── proposed-feature.md
│   └── workflows/
│       ├── add-to-bugs-board.yml
│       ├── ci.yml
│       ├── ci_image_build.yml
│       ├── clippy_rustfmt.yml
│       ├── dependency-updates.yml
│       ├── packaging.yml
│       ├── release.yml
│       └── report_packaging_failures.yml
├── .gitignore
├── Cargo.toml
├── Changelog.md
├── LICENSE
├── NOTICE
├── Readme.md
├── crates/
│   ├── aggregate_builder/
│   │   ├── Cargo.toml
│   │   ├── Readme.md
│   │   └── src/
│   │       └── lib.rs
│   ├── asap/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── fft.rs
│   │       └── lib.rs
│   ├── count-min-sketch/
│   │   ├── Cargo.toml
│   │   ├── src/
│   │   │   └── lib.rs
│   │   └── tests/
│   │       └── lib.rs
│   ├── counter-agg/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── lib.rs
│   │       ├── range.rs
│   │       └── tests.rs
│   ├── encodings/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── flat_serialize/
│   │   ├── Readme.md
│   │   ├── example_generated.rs
│   │   ├── flat_serialize/
│   │   │   ├── Cargo.toml
│   │   │   └── src/
│   │   │       └── lib.rs
│   │   └── flat_serialize_macro/
│   │       ├── Cargo.toml
│   │       └── src/
│   │           ├── lib.rs
│   │           └── parser.rs
│   ├── hyperloglogplusplus/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── dense.rs
│   │       ├── hyperloglog_data.rs
│   │       ├── lib.rs
│   │       ├── registers.rs
│   │       ├── sparse/
│   │       │   └── varint.rs
│   │       └── sparse.rs
│   ├── scripting-utilities/
│   │   ├── Readme.md
│   │   ├── control_file_reader/
│   │   │   ├── Cargo.toml
│   │   │   └── src/
│   │   │       └── lib.rs
│   │   └── postgres_connection_configuration/
│   │       ├── Cargo.toml
│   │       └── src/
│   │           └── lib.rs
│   ├── stats-agg/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── lib.rs
│   │       ├── stats1d.rs
│   │       ├── stats2d/
│   │       │   └── stats2d_flat_serialize.rs
│   │       └── stats2d.rs
│   ├── t-digest/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── t-digest-lib/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── time-weighted-average/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── tspoint/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   └── udd-sketch/
│       ├── Cargo.toml
│       └── src/
│           └── lib.rs
├── docker/
│   ├── README.md
│   └── ci/
│       ├── Dockerfile
│       └── setup.sh
├── docs/
│   ├── README.md
│   ├── asap.md
│   ├── client.md
│   ├── counter_agg.md
│   ├── examples/
│   │   ├── tdigest.c
│   │   └── tdigest.py
│   ├── gauge_agg.md
│   ├── hyperloglog.md
│   ├── lttb.md
│   ├── ordered-aggregates.md
│   ├── percentile_approximation.md
│   ├── release.md
│   ├── rolling_average_api_working.md
│   ├── state_agg.md
│   ├── stats_agg.md
│   ├── tdigest.md
│   ├── template.md
│   ├── test_caggs.md
│   ├── test_candlestick_agg.md
│   ├── time_weighted_average.md
│   ├── timeseries.md
│   ├── timeseries_pipeline_elements.md
│   ├── two-step_aggregation.md
│   └── uddsketch.md
├── extension/
│   ├── .gitignore
│   ├── Cargo.toml
│   ├── src/
│   │   ├── accessors/
│   │   │   └── tests.rs
│   │   ├── accessors.rs
│   │   ├── aggregate_builder_tests.rs
│   │   ├── aggregate_utils.rs
│   │   ├── asap.rs
│   │   ├── bin/
│   │   │   └── pgrx_embed.rs
│   │   ├── candlestick.rs
│   │   ├── counter_agg/
│   │   │   └── accessors.rs
│   │   ├── counter_agg.rs
│   │   ├── countminsketch.rs
│   │   ├── datum_utils.rs
│   │   ├── duration.rs
│   │   ├── frequency.rs
│   │   ├── gauge_agg.rs
│   │   ├── heartbeat_agg/
│   │   │   └── accessors.rs
│   │   ├── heartbeat_agg.rs
│   │   ├── hyperloglog.rs
│   │   ├── lib.rs
│   │   ├── lttb.rs
│   │   ├── nmost/
│   │   │   ├── max_by_float.rs
│   │   │   ├── max_by_int.rs
│   │   │   ├── max_by_time.rs
│   │   │   ├── max_float.rs
│   │   │   ├── max_int.rs
│   │   │   ├── max_time.rs
│   │   │   ├── min_by_float.rs
│   │   │   ├── min_by_int.rs
│   │   │   ├── min_by_time.rs
│   │   │   ├── min_float.rs
│   │   │   ├── min_int.rs
│   │   │   └── min_time.rs
│   │   ├── nmost.rs
│   │   ├── palloc.rs
│   │   ├── pg_any_element.rs
│   │   ├── range.rs
│   │   ├── raw.rs
│   │   ├── saturation.rs
│   │   ├── serialization/
│   │   │   ├── collations.rs
│   │   │   ├── functions.rs
│   │   │   └── types.rs
│   │   ├── serialization.rs
│   │   ├── stabilization_info.rs
│   │   ├── stabilization_tests.rs
│   │   ├── state_aggregate/
│   │   │   ├── accessors.rs
│   │   │   └── rollup.rs
│   │   ├── state_aggregate.rs
│   │   ├── stats_agg.rs
│   │   ├── tdigest.rs
│   │   ├── time_vector/
│   │   │   ├── iter.rs
│   │   │   ├── pipeline/
│   │   │   │   ├── aggregation.rs
│   │   │   │   ├── arithmetic.rs
│   │   │   │   ├── delta.rs
│   │   │   │   ├── expansion.rs
│   │   │   │   ├── fill_to.rs
│   │   │   │   ├── filter.rs
│   │   │   │   ├── lambda/
│   │   │   │   │   ├── executor.rs
│   │   │   │   │   ├── lambda_expr.pest
│   │   │   │   │   └── parser.rs
│   │   │   │   ├── lambda.rs
│   │   │   │   ├── map.rs
│   │   │   │   └── sort.rs
│   │   │   └── pipeline.rs
│   │   ├── time_vector.rs
│   │   ├── time_weighted_average/
│   │   │   └── accessors.rs
│   │   ├── time_weighted_average.rs
│   │   ├── type_builder.rs
│   │   ├── uddsketch.rs
│   │   └── utilities.rs
│   └── timescaledb_toolkit.control
├── tests/
│   └── update/
│       ├── candlestick.md
│       ├── heartbeat.md
│       ├── original_update_tests.md
│       ├── state_agg.md
│       ├── time-vector.md
│       └── time-weighted-average.md
└── tools/
    ├── build
    ├── dependencies.sh
    ├── install-timescaledb
    ├── post-install/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── main.rs
    │       └── update_script.rs
    ├── release
    ├── sql-doctester/
    │   ├── Cargo.toml
    │   ├── Readme.md
    │   └── src/
    │       ├── main.rs
    │       ├── parser.rs
    │       ├── runner.rs
    │       └── startup.sql
    ├── testbin
    └── update-tester/
        ├── Cargo.toml
        ├── Readme.md
        └── src/
            ├── installer.rs
            ├── main.rs
            ├── parser.rs
            ├── testrunner/
            │   └── stabilization.rs
            └── testrunner.rs

SYMBOL INDEX (2504 symbols across 107 files)

FILE: crates/aggregate_builder/src/lib.rs
  function aggregate (line 19) | pub fn aggregate(_attr: TokenStream, item: TokenStream) -> TokenStream {
  type Aggregate (line 34) | struct Aggregate {
  type AggregateItem (line 50) | enum AggregateItem {
  type AggregateTy (line 56) | struct AggregateTy {
  type AggregateParallelSafe (line 61) | struct AggregateParallelSafe {
  type AggregateFn (line 65) | struct AggregateFn {
    method transition_fn_tokens (line 592) | fn transition_fn_tokens(
    method final_fn_tokens (line 705) | fn final_fn_tokens(
    method serialize_fn_tokens (line 762) | fn serialize_fn_tokens(
    method deserialize_fn_tokens (line 821) | fn deserialize_fn_tokens(
    method combine_fn_tokens (line 879) | fn combine_fn_tokens(
    method outer_ident (line 958) | fn outer_ident(&self, aggregate_name: &syn::Ident) -> syn::Ident {
    method sql_args (line 966) | fn sql_args(&self) -> impl Iterator<Item = (Option<&syn::Ident>, Strin...
  type AggregateArg (line 76) | struct AggregateArg {
  method parse (line 99) | fn parse(input: ParseStream) -> syn::Result<Self> {
  method parse (line 255) | fn parse(input: ParseStream) -> syn::Result<Self> {
  method parse (line 272) | fn parse(input: ParseStream) -> syn::Result<Self> {
  method parse (line 283) | fn parse(input: ParseStream) -> syn::Result<Self> {
  function is_fcinfo (line 304) | fn is_fcinfo(arg: &AggregateArg) -> bool {
  method parse (line 316) | fn parse(input: ParseStream) -> syn::Result<Self> {
  method parse (line 368) | fn parse(input: ParseStream) -> syn::Result<Self> {
  function take_attr (line 386) | fn take_attr(attrs: &mut Vec<syn::Attribute>, path: &syn::Path) -> Optio...
  function expand (line 401) | fn expand(agg: Aggregate) -> TokenStream2 {
  function arg_ident (line 977) | fn arg_ident(arg: &AggregateArg) -> syn::Pat {
  function make_mod_counters (line 981) | fn make_mod_counters() -> TokenStream2 {
  function ret_type (line 1018) | fn ret_type(ret: &syn::ReturnType) -> Cow<'_, syn::Type> {
  function state_type_check_tokens (line 1025) | fn state_type_check_tokens(ty: &syn::Type, optional: Option<()>) -> Toke...
  function refstate_type_check_tokens (line 1032) | fn refstate_type_check_tokens(ty: &syn::Type, optional: Option<()>) -> T...
  function bytea_type_check_tokens (line 1053) | fn bytea_type_check_tokens(ty: &syn::Type) -> TokenStream2 {
  function type_check_tokens (line 1057) | fn type_check_tokens(user_ty: &syn::Type, expected_type: syn::Type) -> T...

FILE: crates/asap/src/fft.rs
  function transform (line 35) | pub fn transform(real: &mut [f64], imag: &mut [f64]) {
  function inverse_transform (line 53) | pub fn inverse_transform(real: &mut [f64], imag: &mut [f64]) {
  function transform_radix2 (line 61) | fn transform_radix2(real: &mut [f64], imag: &mut [f64]) {
  function transform_bluestein (line 131) | fn transform_bluestein(real: &mut [f64], imag: &mut [f64]) {
  function convolve_complex (line 204) | fn convolve_complex(

FILE: crates/asap/src/lib.rs
  function asap_smooth (line 29) | pub fn asap_smooth(data: &[f64], resolution: u32) -> Vec<f64> {
  function binary_search (line 90) | fn binary_search(
  function sma (line 122) | fn sma(data: &[f64], range: u32, slide: u32) -> Vec<f64> {
  function mean (line 145) | fn mean(values: &[f64]) -> f64 {
  function std (line 149) | fn std(values: &[f64]) -> f64 {
  function new (line 157) | fn new(values: &'a [f64], max_lag: u32) -> Acf<'a> {
  function calculate (line 168) | fn calculate(&mut self) {
  function find_peaks (line 194) | fn find_peaks(&mut self) -> Vec<u32> {
  type Metrics (line 235) | struct Metrics<'a> {
  function new (line 242) | fn new(values: &[f64]) -> Metrics<'_> {
  function kurtosis (line 250) | fn kurtosis(&self) -> f64 {
  function roughness (line 262) | fn roughness(&self) -> f64 {
  function diffs (line 266) | fn diffs(&self) -> Vec<f64> {
  type Acf (line 275) | struct Acf<'a> {
  function simple_sma_test (line 287) | fn simple_sma_test() {
  function sma_slide_test (line 295) | fn sma_slide_test() {
  function sma_slide_unaliged_test (line 303) | fn sma_slide_unaliged_test() {
  function sma_downsample_test (line 311) | fn sma_downsample_test() {
  function test_roughness_and_kurtosis (line 319) | fn test_roughness_and_kurtosis() {
  function test_smoothing (line 348) | fn test_smoothing() {

FILE: crates/count-min-sketch/src/lib.rs
  type CountMinHashFn (line 20) | pub struct CountMinHashFn {
    method with_key (line 28) | pub fn with_key(key: u64) -> Self {
    method hash_into_buckets (line 37) | pub fn hash_into_buckets<T: Hash>(&self, item: &T, nbuckets: usize) ->...
    method key (line 46) | pub(crate) fn key(&self) -> u64 {
  constant SEED (line 24) | const SEED: u64 = 0x517cc1b727220a95;
  type CountMinSketch (line 64) | pub struct CountMinSketch {
    method new (line 77) | pub fn new(
    method with_dims_and_hashfn_keys (line 96) | pub fn with_dims_and_hashfn_keys(width: usize, depth: usize, keys: Vec...
    method with_dim (line 110) | pub fn with_dim(width: usize, depth: usize) -> Self {
    method with_prob (line 130) | pub fn with_prob(epsilon: f64, delta: f64) -> Self {
    method width (line 139) | pub fn width(&self) -> usize {
    method depth (line 144) | pub fn depth(&self) -> usize {
    method hash_keys (line 150) | pub fn hash_keys(&self) -> Vec<u64> {
    method counters (line 158) | pub fn counters(&self) -> &Vec<Vec<i64>> {
    method estimate (line 164) | pub fn estimate<T: Hash>(&self, item: T) -> i64 {
    method get_bucket_indices (line 182) | pub fn get_bucket_indices<T: Hash>(&self, item: T) -> Vec<usize> {
    method add_value (line 190) | pub fn add_value<T: Hash>(&mut self, item: T) {
    method subtract_value (line 198) | pub fn subtract_value<T: Hash>(&mut self, item: T) {
    method combine (line 209) | pub fn combine(&mut self, other: CountMinSketch) {
    method fmt (line 222) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: crates/count-min-sketch/tests/lib.rs
  function empty_sketch (line 4) | fn empty_sketch() {
  function add_once (line 10) | fn add_once() {
  function subtract_is_inverse_of_add (line 17) | fn subtract_is_inverse_of_add() {
  function add_repeated (line 25) | fn add_repeated() {
  function add_repeated_with_collisions (line 34) | fn add_repeated_with_collisions() {

FILE: crates/counter-agg/src/lib.rs
  type CounterError (line 12) | pub enum CounterError {
    method fmt (line 300) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  type MetricSummary (line 25) | pub struct MetricSummary {
    method new (line 67) | pub fn new(pt: &TSPoint, bounds: Option<range::I64Range>) -> MetricSum...
    method reset (line 83) | fn reset(&mut self, incoming: &TSPoint) {
    method add_point (line 91) | fn add_point(&mut self, incoming: &TSPoint) -> Result<(), CounterError> {
    method single_value (line 117) | fn single_value(&self) -> bool {
    method combine (line 122) | fn combine(&mut self, incoming: &MetricSummary) -> Result<(), CounterE...
    method time_delta (line 159) | pub fn time_delta(&self) -> f64 {
    method delta (line 163) | pub fn delta(&self) -> f64 {
    method rate (line 167) | pub fn rate(&self) -> Option<f64> {
    method idelta_left (line 174) | pub fn idelta_left(&self) -> f64 {
    method idelta_right (line 183) | pub fn idelta_right(&self) -> f64 {
    method irate_left (line 192) | pub fn irate_left(&self) -> Option<f64> {
    method irate_right (line 200) | pub fn irate_right(&self) -> Option<f64> {
    method bounds_valid (line 208) | pub fn bounds_valid(&self) -> bool {
    method bounds_extend (line 215) | fn bounds_extend(&mut self, in_bounds: Option<range::I64Range>) {
    method prometheus_delta (line 228) | pub fn prometheus_delta(&self) -> Result<Option<f64>, CounterError> {
    method prometheus_rate (line 284) | pub fn prometheus_rate(&self) -> Result<Option<f64>, CounterError> {
  function ts_to_xy (line 52) | fn ts_to_xy(pt: TSPoint) -> XYPair<f64> {
  function to_seconds (line 59) | fn to_seconds(t: f64) -> f64 {
  type GaugeSummaryBuilder (line 312) | pub struct GaugeSummaryBuilder(MetricSummary);
    method new (line 315) | pub fn new(pt: &TSPoint, bounds: Option<range::I64Range>) -> Self {
    method add_point (line 320) | pub fn add_point(&mut self, incoming: &TSPoint) -> Result<(), CounterE...
    method combine (line 325) | pub fn combine(&mut self, incoming: &MetricSummary) -> Result<(), Coun...
    method set_bounds (line 329) | pub fn set_bounds(&mut self, bounds: Option<range::I64Range>) {
    method build (line 333) | pub fn build(self) -> MetricSummary {
    method first (line 337) | pub fn first(&self) -> &TSPoint {
    method bounds_valid (line 342) | pub fn bounds_valid(&self) -> bool {
    method from (line 348) | fn from(summary: MetricSummary) -> Self {
  type CounterSummaryBuilder (line 354) | pub struct CounterSummaryBuilder(MetricSummary);
    method new (line 357) | pub fn new(pt: &TSPoint, bounds: Option<range::I64Range>) -> Self {
    method add_point (line 362) | pub fn add_point(&mut self, incoming: &TSPoint) -> Result<(), CounterE...
    method combine (line 368) | pub fn combine(&mut self, incoming: &MetricSummary) -> Result<(), Coun...
    method set_bounds (line 373) | pub fn set_bounds(&mut self, bounds: Option<range::I64Range>) {
    method build (line 377) | pub fn build(self) -> MetricSummary {
    method first (line 381) | pub fn first(&self) -> &TSPoint {
    method bounds_valid (line 386) | pub fn bounds_valid(&self) -> bool {
    method from (line 392) | fn from(summary: MetricSummary) -> Self {

FILE: crates/counter-agg/src/range.rs
  type I64Range (line 10) | pub struct I64Range {
    method has_infinite (line 16) | pub fn has_infinite(&self) -> bool {
    method is_valid (line 26) | fn is_valid(&self) -> bool {
    method is_singleton (line 33) | pub fn is_singleton(&self) -> bool {
    method extend (line 40) | pub fn extend(&mut self, other: &Self) {
    method contains (line 54) | pub fn contains(&self, pt: i64) -> bool {
    method duration (line 66) | pub fn duration(&self) -> Option<i64> {
  function test_extend (line 78) | fn test_extend() {
  function test_contains (line 243) | fn test_contains() {
  function test_duration (line 281) | fn test_duration() {
  function test_checks (line 311) | fn test_checks() {

FILE: crates/counter-agg/src/tests.rs
  function to_micro (line 6) | fn to_micro(t: f64) -> f64 {
  function assert_close_enough (line 11) | pub fn assert_close_enough(p1: &MetricSummary, p2: &MetricSummary) {
  function create (line 27) | fn create() {
  function adding_point (line 37) | fn adding_point() {
  function adding_points_to_counter (line 54) | fn adding_points_to_counter() {
  function adding_out_of_order_counter (line 82) | fn adding_out_of_order_counter() {
  function test_counter_delta (line 94) | fn test_counter_delta() {
  function test_combine (line 111) | fn test_combine() {
  function test_combine_with_small_summary (line 141) | fn test_combine_with_small_summary() {
  function test_multiple_resets (line 161) | fn test_multiple_resets() {
  function test_extraction_single_point (line 209) | fn test_extraction_single_point() {
  function test_extraction_simple (line 223) | fn test_extraction_simple() {
  function test_extraction_with_resets (line 241) | fn test_extraction_with_resets() {
  function test_bounds (line 259) | fn test_bounds() {
  function test_prometheus_extrapolation_simple (line 376) | fn test_prometheus_extrapolation_simple() {
  function test_prometheus_extrapolation_bound_size (line 508) | fn test_prometheus_extrapolation_bound_size() {

FILE: crates/encodings/src/lib.rs
  function i64_decoder (line 4) | pub fn i64_decoder() -> impl FnMut(i64) -> i64 {
  function u64_decoder (line 13) | pub fn u64_decoder() -> impl FnMut(u64) -> u64 {
  function i64_encoder (line 23) | pub fn i64_encoder() -> impl FnMut(i64) -> i64 {
  function u64_encoder (line 32) | pub fn u64_encoder() -> impl FnMut(u64) -> u64 {
  function quick_test_roundtrip_u64 (line 48) | fn quick_test_roundtrip_u64(values: Vec<u64>) -> bool {
  function quick_test_roundtrip_i64 (line 63) | fn quick_test_roundtrip_i64(values: Vec<i64>) -> bool {
  function encode (line 81) | pub fn encode(n: i64) -> u64 {
  function decode (line 93) | pub fn decode(n: u64) -> i64 {
  function size_vec (line 126) | pub fn size_vec<I: Iterator<Item = u64>>(bytes: &mut Vec<u8>, values: I) {
  function bytes_for_value (line 132) | pub fn bytes_for_value(value: u64) -> u32 {
  type I64Compressor (line 140) | pub struct I64Compressor<F: FnMut(i64) -> i64> {
  function new (line 146) | pub fn new() -> Self {
  method default (line 155) | fn default() -> Self {
  function with (line 161) | pub fn with(encoder: F) -> Self {
  function push (line 168) | pub fn push(&mut self, value: i64) {
  function finish (line 173) | pub fn finish(self) -> Vec<u8> {
  type U64Compressor (line 178) | pub struct U64Compressor<F: FnMut(u64) -> u64> {
  function new (line 184) | pub fn new() -> Self {
  method default (line 193) | fn default() -> Self {
  function with (line 199) | pub fn with(encoder: F) -> Self {
  function push (line 206) | pub fn push(&mut self, value: u64) {
  function finish (line 211) | pub fn finish(self) -> Vec<u8> {
  function is_empty (line 215) | pub fn is_empty(&self) -> bool {
  function compress_i64s_to_vec (line 220) | pub fn compress_i64s_to_vec<I: Iterator<Item = i64>>(bytes: &mut Vec<u8>...
  function compress_u64s_to_vec (line 224) | pub fn compress_u64s_to_vec<I: Iterator<Item = u64>>(bytes: &mut Vec<u8>...
  function write_to_vec (line 231) | pub fn write_to_vec(out: &mut Vec<u8>, mut value: u64) {
  type Value (line 250) | type Value = u64;
  function i64_decompressor (line 252) | pub fn i64_decompressor(bytes: &[u8]) -> impl Iterator<Item = i64> + '_ {
  function u64_decompressor (line 256) | pub fn u64_decompressor(mut bytes: &[u8]) -> impl Iterator<Item = u64> +...
  function read_from_slice (line 269) | pub fn read_from_slice(bytes: &[u8]) -> (Value, usize) {
  function prefix_length (line 295) | pub fn prefix_length(tag_byte: u8) -> u32 {
  function quick_test_roundtrip_u64 (line 306) | fn quick_test_roundtrip_u64(values: Vec<u64>) -> bool {
  function quick_test_roundtrip_i64 (line 316) | fn quick_test_roundtrip_i64(values: Vec<i64>) -> bool {

FILE: crates/flat_serialize/example_generated.rs
  type Basic (line 4) | pub struct Basic<'input> {
  constant _ (line 12) | const _: () = {
  constant _ (line 68) | const _: () = {
  constant REQUIRED_ALIGNMENT (line 81) | const REQUIRED_ALIGNMENT: usize = {
  constant MAX_PROVIDED_ALIGNMENT (line 106) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
  constant MIN_LEN (line 160) | const MIN_LEN: usize = {
  constant TRIVIAL_COPY (line 170) | const TRIVIAL_COPY: bool = false;
  type SLICE (line 171) | type SLICE = flat_serialize::Iterable<'input, Basic<'input>>;
  function try_ref (line 174) | unsafe fn try_ref(
  function fill_slice (line 285) | unsafe fn fill_slice<'out>(
  function len (line 320) | fn len(&self) -> usize {
  type Optional (line 337) | pub struct Optional {
    constant REQUIRED_ALIGNMENT (line 386) | const REQUIRED_ALIGNMENT: usize = {
    constant MAX_PROVIDED_ALIGNMENT (line 403) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
    constant MIN_LEN (line 449) | const MIN_LEN: usize = {
    constant TRIVIAL_COPY (line 457) | const TRIVIAL_COPY: bool = false;
    type SLICE (line 458) | type SLICE = flat_serialize::Iterable<'a, Optional>;
    method try_ref (line 461) | unsafe fn try_ref(mut input: &[u8]) -> Result<(Self, &[u8]), flat_seri...
    method fill_slice (line 534) | unsafe fn fill_slice<'out>(
    method len (line 562) | fn len(&self) -> usize {
  constant _ (line 343) | const _: () = {
  constant _ (line 377) | const _: () = {
  type Nested (line 579) | pub struct Nested<'a> {
  constant _ (line 584) | const _: () = {
  constant _ (line 608) | const _: () = {
  constant REQUIRED_ALIGNMENT (line 615) | const REQUIRED_ALIGNMENT: usize = {
  constant MAX_PROVIDED_ALIGNMENT (line 628) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
  constant MIN_LEN (line 661) | const MIN_LEN: usize = {
  constant TRIVIAL_COPY (line 668) | const TRIVIAL_COPY: bool = false;
  type SLICE (line 669) | type SLICE = flat_serialize::Iterable<'a, Nested<'a>>;
  function try_ref (line 672) | unsafe fn try_ref(mut input: &'a [u8]) -> Result<(Self, &'a [u8]), flat_...
  function fill_slice (line 718) | unsafe fn fill_slice<'out>(
  function len (line 736) | fn len(&self) -> usize {
  type NestedOptional (line 744) | pub struct NestedOptional {
    constant REQUIRED_ALIGNMENT (line 782) | const REQUIRED_ALIGNMENT: usize = {
    constant MAX_PROVIDED_ALIGNMENT (line 795) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
    constant MIN_LEN (line 834) | const MIN_LEN: usize = {
    constant TRIVIAL_COPY (line 841) | const TRIVIAL_COPY: bool = false;
    type SLICE (line 842) | type SLICE = flat_serialize::Iterable<'a, NestedOptional>;
    method try_ref (line 845) | unsafe fn try_ref(mut input: &[u8]) -> Result<(Self, &[u8]), flat_seri...
    method fill_slice (line 902) | unsafe fn fill_slice<'out>(
    method len (line 923) | fn len(&self) -> usize {
  constant _ (line 749) | const _: () = {
  constant _ (line 775) | const _: () = {
  type NestedSlice (line 935) | pub struct NestedSlice<'b> {
  constant _ (line 940) | const _: () = {
  constant _ (line 966) | const _: () = {
  constant REQUIRED_ALIGNMENT (line 973) | const REQUIRED_ALIGNMENT: usize = {
  constant MAX_PROVIDED_ALIGNMENT (line 986) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
  constant MIN_LEN (line 1019) | const MIN_LEN: usize = {
  constant TRIVIAL_COPY (line 1026) | const TRIVIAL_COPY: bool = false;
  type SLICE (line 1027) | type SLICE = flat_serialize::Iterable<'b, NestedSlice<'b>>;
  function try_ref (line 1030) | unsafe fn try_ref(mut input: &'b [u8]) -> Result<(Self, &'b [u8]), flat_...
  function fill_slice (line 1084) | unsafe fn fill_slice<'out>(
  function len (line 1103) | fn len(&self) -> usize {
  type BasicEnum (line 1111) | pub enum BasicEnum<'input> {
  constant _ (line 1121) | const _: () = {
  constant _ (line 1177) | const _: () = {
  constant _ (line 1184) | const _: () = {
  constant REQUIRED_ALIGNMENT (line 1203) | const REQUIRED_ALIGNMENT: usize = {
  constant MAX_PROVIDED_ALIGNMENT (line 1237) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
  constant MIN_LEN (line 1330) | const MIN_LEN: usize = {
  constant TRIVIAL_COPY (line 1359) | const TRIVIAL_COPY: bool = false;
  type SLICE (line 1360) | type SLICE = flat_serialize::Iterable<'input, BasicEnum<'input>>;
  function try_ref (line 1363) | unsafe fn try_ref(
  function fill_slice (line 1467) | unsafe fn fill_slice<'out>(
  function len (line 1501) | fn len(&self) -> usize {
  type PaddedEnum (line 1516) | pub enum PaddedEnum<'input> {
  constant _ (line 1528) | const _: () = {
  constant _ (line 1604) | const _: () = {
  constant _ (line 1611) | const _: () = {
  constant REQUIRED_ALIGNMENT (line 1634) | const REQUIRED_ALIGNMENT: usize = {
  constant MAX_PROVIDED_ALIGNMENT (line 1676) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
  constant MIN_LEN (line 1785) | const MIN_LEN: usize = {
  constant TRIVIAL_COPY (line 1816) | const TRIVIAL_COPY: bool = false;
  type SLICE (line 1817) | type SLICE = flat_serialize::Iterable<'input, PaddedEnum<'input>>;
  function try_ref (line 1820) | unsafe fn try_ref(
  function fill_slice (line 1955) | unsafe fn fill_slice<'out>(
  function len (line 1999) | fn len(&self) -> usize {

FILE: crates/flat_serialize/flat_serialize/src/lib.rs
  type WrapErr (line 8) | pub enum WrapErr {
  type FlatSerializable (line 25) | pub unsafe trait FlatSerializable<'input>: Sized + 'input {
    constant MIN_LEN (line 26) | const MIN_LEN: usize;
    constant REQUIRED_ALIGNMENT (line 27) | const REQUIRED_ALIGNMENT: usize;
    constant MAX_PROVIDED_ALIGNMENT (line 28) | const MAX_PROVIDED_ALIGNMENT: Option<usize>;
    constant TRIVIAL_COPY (line 29) | const TRIVIAL_COPY: bool = false;
    method try_ref (line 34) | unsafe fn try_ref(input: &'input [u8]) -> Result<(Self, &'input [u8]),...
    method fill_vec (line 35) | fn fill_vec(&self, input: &mut Vec<u8>) {
    method fill_slice (line 54) | unsafe fn fill_slice<'out>(
    method num_bytes (line 58) | fn num_bytes(&self) -> usize;
    method make_owned (line 60) | fn make_owned(&mut self);
    method into_owned (line 61) | fn into_owned(self) -> Self::OWNED;
  constant MIN_LEN (line 131) | const MIN_LEN: usize = { T::MIN_LEN * N };
  constant REQUIRED_ALIGNMENT (line 132) | const REQUIRED_ALIGNMENT: usize = T::REQUIRED_ALIGNMENT;
  constant MAX_PROVIDED_ALIGNMENT (line 133) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = T::MAX_PROVIDED_ALIGNMENT;
  constant TRIVIAL_COPY (line 134) | const TRIVIAL_COPY: bool = T::TRIVIAL_COPY;
  type SLICE (line 136) | type SLICE = Slice<'i, [T; N]>;
  type OWNED (line 137) | type OWNED = [T::OWNED; N];
  function try_ref (line 140) | unsafe fn try_ref(mut input: &'i [u8]) -> Result<(Self, &'i [u8]), WrapE...
  function fill_slice (line 158) | unsafe fn fill_slice<'out>(
  function num_bytes (line 179) | fn num_bytes(&self) -> usize {
  function make_owned (line 183) | fn make_owned(&mut self) {
  function into_owned (line 189) | fn into_owned(self) -> Self::OWNED {
  type Slice (line 203) | pub enum Slice<'input, T: 'input> {
  function iter (line 210) | pub fn iter<'s>(&'s self) -> Iter<'input, 's, T>
  type Item (line 226) | type Item = T;
  type IntoIter (line 228) | type IntoIter = Iter<'input, 'input, T>;
  function into_iter (line 230) | fn into_iter(self) -> Self::IntoIter {
  type Iter (line 239) | pub enum Iter<'input, 'borrow, T: 'input> {
  type Item (line 249) | type Item = T;
  method next (line 251) | fn next(&mut self) -> Option<Self::Item> {
  method nth (line 274) | fn nth(&mut self, n: usize) -> Option<Self::Item> {
  function len (line 295) | pub fn len(&self) -> usize {
  function is_empty (line 303) | pub fn is_empty(&self) -> bool {
  function fmt (line 316) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method eq (line 325) | fn eq(&self, other: &Self) -> bool {
  type Unflatten (line 333) | pub struct Unflatten<'input, T: 'input> {
  function from_bytes (line 340) | pub unsafe fn from_bytes(bytes: &'input [u8]) -> Self {
  function len (line 347) | pub fn len(&self) -> usize
  function is_empty (line 358) | pub fn is_empty(&self) -> bool
  function make_owned (line 369) | pub fn make_owned(&mut self)
  function into_vec (line 376) | pub fn into_vec(self) -> Vec<T::OWNED>
  function into_owned (line 387) | pub fn into_owned(self) -> Slice<'static, T::OWNED>
  function as_owned (line 394) | pub fn as_owned(&mut self) -> &mut Vec<T>
  function as_slice (line 414) | pub fn as_slice(&self) -> &[T]
  function slice (line 425) | pub fn slice(&self) -> &'input [T]
  type Item (line 440) | type Item = T;
  method next (line 442) | fn next(&mut self) -> Option<Self::Item> {
  function from (line 453) | fn from(val: &'input [T]) -> Self {
  function from (line 459) | fn from(val: Vec<T>) -> Self {
  method clone (line 468) | fn clone(&self) -> Self {
  function serialize (line 481) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function deserialize (line 499) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method clone (line 509) | fn clone(&self) -> Self {
  type VariableLen (line 517) | pub unsafe trait VariableLen<'input>: Sized {
    method try_ref (line 519) | unsafe fn try_ref(input: &'input [u8], count: usize) -> Result<(Self, ...
    method fill_slice (line 522) | unsafe fn fill_slice<'out>(
    method num_bytes (line 527) | fn num_bytes(&self, count: usize) -> usize;
  function try_ref (line 535) | unsafe fn try_ref(input: &'i [u8], count: usize) -> Result<(Self, &'i [u...
  function fill_slice (line 552) | unsafe fn fill_slice<'out>(
  function num_bytes (line 571) | fn num_bytes(&self, count: usize) -> usize {
  function try_ref (line 585) | unsafe fn try_ref(input: &'i [u8], count: usize) -> Result<(Self, &'i [u...
  function fill_slice (line 618) | unsafe fn fill_slice<'out>(
  function num_bytes (line 630) | fn num_bytes(&self, count: usize) -> usize {
  function fill_slice_from_iter (line 639) | unsafe fn fill_slice_from_iter<
  function len_of_iterable (line 667) | fn len_of_iterable<'i, T: FlatSerializable<'i>, V: ValOrRef<T>, I: Itera...
  function aligning_len (line 687) | fn aligning_len(ptr: *const MaybeUninit<u8>, align: usize) -> usize {
  type ValOrRef (line 695) | trait ValOrRef<T: ?Sized> {
    method to_ref (line 696) | fn to_ref(&self) -> &T;
  method to_ref (line 700) | fn to_ref(&self) -> &T {
  function to_ref (line 706) | fn to_ref(&self) -> &T {
  function basic (line 729) | fn basic() {
  function bad_len1 (line 797) | fn bad_len1() {
  function bad_len2 (line 812) | fn bad_len2() {
  constant _TEST_NO_VARIABLE_LEN_NO_LIFETIME (line 834) | const _TEST_NO_VARIABLE_LEN_NO_LIFETIME: Optional = Optional {
  function optional_present (line 841) | fn optional_present() {
  function optional_absent (line 881) | fn optional_absent() {
  function nested (line 923) | fn nested() {
  function nested_optional (line 990) | fn nested_optional() {
  function nested_slice (line 1042) | fn nested_slice() {
  function basic_enum1 (line 1122) | fn basic_enum1() {
  function basic_enum2 (line 1148) | fn basic_enum2() {
  function padded_enum1 (line 1195) | fn padded_enum1() {
  function padded_enum2 (line 1239) | fn padded_enum2() {
  function many_enum (line 1279) | fn many_enum() {
  function test_no_refrence (line 1377) | fn test_no_refrence() {
  function test_size_align_struct (line 1445) | fn test_size_align_struct() {
  function test_size_align_enum (line 1647) | fn test_size_align_enum() {
  type Foo (line 1809) | struct Foo {
  constant _ (line 1814) | const _: () = {
  function foo (line 1821) | fn foo() {
  type Bar (line 1849) | enum Bar {
  constant _ (line 1854) | const _: () = {
  function fs_enum_a (line 1861) | fn fs_enum_a() {
  function fs_enum_b (line 1885) | fn fs_enum_b() {
  function fs_enum_non (line 1904) | fn fs_enum_non() {

FILE: crates/flat_serialize/flat_serialize_macro/src/lib.rs
  function flat_serialize (line 15) | pub fn flat_serialize(input: TokenStream) -> TokenStream {
  type FlatSerialize (line 29) | enum FlatSerialize {
  type FlatSerializeEnum (line 50) | struct FlatSerializeEnum {
    method variants (line 392) | fn variants(&self, lifetime: Option<&TokenStream2>) -> TokenStream2 {
    method uniqueness_check (line 415) | fn uniqueness_check(&self) -> TokenStream2 {
    method alignment_check (line 434) | fn alignment_check(&self) -> TokenStream2 {
    method fn_trait_check (line 453) | fn fn_trait_check(&self) -> TokenStream2 {
    method fn_required_alignment (line 468) | fn fn_required_alignment(&self) -> TokenStream2 {
    method fn_max_provided_alignment (line 501) | fn fn_max_provided_alignment(&self) -> TokenStream2 {
    method fn_min_len (line 573) | fn fn_min_len(&self) -> TokenStream2 {
    method fn_try_ref (line 605) | fn fn_try_ref(&self, lifetime: Option<&TokenStream2>) -> TokenStream2 {
    method fn_fill_slice (line 662) | fn fn_fill_slice(&self) -> TokenStream2 {
    method fn_len (line 694) | fn fn_len(&self) -> TokenStream2 {
  type FlatSerializeVariant (line 59) | struct FlatSerializeVariant {
  type FlatSerializeStruct (line 108) | struct FlatSerializeStruct {
    method alignment_check (line 721) | fn alignment_check(&self, start: TokenStream2, min_align: TokenStream2...
    method fn_trait_check (line 734) | fn fn_trait_check(&self) -> TokenStream2 {
    method fn_required_alignment (line 743) | fn fn_required_alignment(&self) -> TokenStream2 {
    method fn_max_provided_alignment (line 760) | fn fn_max_provided_alignment(&self) -> TokenStream2 {
    method fn_min_len (line 795) | fn fn_min_len(&self) -> TokenStream2 {
    method fn_try_ref (line 807) | fn fn_try_ref(&self, lifetime: Option<&TokenStream2>) -> TokenStream2 {
    method fn_try_ref_body (line 836) | fn fn_try_ref_body(&self, break_label: &syn::Lifetime) -> TryRefBody {
    method fn_fill_slice (line 866) | fn fn_fill_slice(&self) -> TokenStream2 {
    method fill_slice_body (line 882) | fn fill_slice_body(&self) -> (TokenStream2, TokenStream2) {
    method fn_len (line 892) | fn fn_len(&self) -> TokenStream2 {
  type FlatSerializeField (line 115) | struct FlatSerializeField {
    method alignment_check (line 909) | fn alignment_check(&self) -> TokenStream2 {
    method trait_check (line 950) | fn trait_check(&self) -> TokenStream2 {
    method required_alignment (line 976) | fn required_alignment(&self) -> TokenStream2 {
    method max_provided_alignment (line 986) | fn max_provided_alignment(&self) -> TokenStream2 {
    method min_len (line 1033) | fn min_len(&self) -> TokenStream2 {
    method try_wrap (line 1047) | fn try_wrap(&self, break_label: &syn::Lifetime) -> TokenStream2 {
    method fill_slice (line 1111) | fn fill_slice(&self) -> TokenStream2 {
    method err_size (line 1154) | fn err_size(&self) -> TokenStream2 {
    method exposed_ty (line 1185) | fn exposed_ty(&self, lifetime: Option<&TokenStream2>) -> TokenStream2 {
    method local_ty (line 1212) | fn local_ty(&self) -> TokenStream2 {
    method size_fn (line 1235) | fn size_fn(&self) -> TokenStream2 {
    method make_owned (line 1270) | fn make_owned(&self) -> TokenStream2 {
    method into_owned (line 1294) | fn into_owned(&self) -> TokenStream2 {
    method declaration (line 1317) | fn declaration<'a, 'b: 'a>(
    method per_field_attrs (line 1331) | fn per_field_attrs<'a, 'b: 'a>(
    method ty_without_lifetime (line 1347) | fn ty_without_lifetime(&self) -> TokenStream2 {
    method is_optional (line 1357) | fn is_optional(&self) -> bool {
  type PerFieldsAttr (line 125) | struct PerFieldsAttr {
  type VariableLenFieldInfo (line 131) | struct VariableLenFieldInfo {
    method len_from_bytes (line 338) | fn len_from_bytes(&self) -> TokenStream2 {
    method counter_expr (line 345) | fn counter_expr(&self) -> TokenStream2 {
    method err_size_expr (line 352) | fn err_size_expr(&self) -> TokenStream2 {
    method ty_without_lifetime (line 1369) | fn ty_without_lifetime(&self) -> TokenStream2 {
  function flat_serialize_struct (line 141) | fn flat_serialize_struct(input: FlatSerializeStruct) -> TokenStream2 {
  function flat_serialize_enum (line 243) | fn flat_serialize_enum(input: FlatSerializeEnum) -> TokenStream2 {
  type SelfReplacer (line 364) | struct SelfReplacer<F: FnMut(&Ident) -> syn::Expr>(F);
  method visit_expr_mut (line 367) | fn visit_expr_mut(&mut self, expr: &mut syn::Expr) {
  type TryRefBody (line 384) | struct TryRefBody {
  function flat_serializable_derive (line 1381) | pub fn flat_serializable_derive(input: TokenStream) -> TokenStream {

FILE: crates/flat_serialize/flat_serialize_macro/src/parser.rs
  constant LIBRARY_MARKER (line 21) | const LIBRARY_MARKER: &str = "flat_serialize";
  function flat_serialize_attr_path (line 23) | fn flat_serialize_attr_path(att_name: &str) -> syn::Path {
  method parse (line 30) | fn parse(input: ParseStream) -> Result<Self> {
  method parse (line 62) | fn parse(input: ParseStream) -> Result<Self> {
  method parse (line 86) | fn parse(input: ParseStream) -> Result<Self> {
  method parse (line 117) | fn parse(input: ParseStream) -> Result<Self> {
  method parse (line 139) | fn parse(input: ParseStream) -> Result<Self> {
  type Target (line 194) | type Target = Field;
  method deref (line 196) | fn deref(&self) -> &Self::Target {
  method parse (line 202) | fn parse(input: ParseStream) -> Result<Self> {
  function has_self_field (line 275) | fn has_self_field(expr: &Expr) -> bool {
  type FindSelf (line 281) | struct FindSelf(bool);
    method visit_path_segment (line 284) | fn visit_path_segment(&mut self, i: &'ast syn::PathSegment) {
  function validate_self_fields (line 305) | fn validate_self_fields<'a>(fields: impl Iterator<Item = &'a mut FlatSer...
  function validate_self_field (line 318) | fn validate_self_field(
  type ValidateLenFields (line 330) | struct ValidateLenFields<'a, 'b>(Option<TokenStream2>, &'b HashSet<&'a I...
  function visit_expr (line 333) | fn visit_expr(&mut self, expr: &'ast syn::Expr) {
  function as_turbofish (line 358) | pub fn as_turbofish(ty: &Type) -> TokenStream2 {
  function has_lifetime (line 411) | pub fn has_lifetime(ty: &Type) -> bool {

FILE: crates/hyperloglogplusplus/src/dense.rs
  type Storage (line 9) | pub struct Storage<'s> {
  function new (line 18) | pub fn new(precision: u8) -> Self {
  function from_parts (line 33) | pub fn from_parts(registers: &'s [u8], precision: u8) -> Self {
  function into_owned (line 43) | pub fn into_owned(&self) -> Storage<'static> {
  function add_hash (line 52) | pub fn add_hash(&mut self, hash: u64) {
  function add_encoded (line 57) | pub fn add_encoded(&mut self, encoded: crate::sparse::Encoded) {
  function idx_count_from_hash (line 62) | fn idx_count_from_hash(&self, hash: u64) -> (usize, u8) {
  function idx_count_from_encoded (line 70) | fn idx_count_from_encoded(&self, encoded: crate::sparse::Encoded) -> (us...
  function estimate_count (line 77) | pub fn estimate_count(&self) -> u64 {
  function linear_counting (line 106) | fn linear_counting(&self, v: f64) -> f64 {
  function threshold (line 111) | fn threshold(&self) -> f64 {
  function a_m (line 115) | fn a_m(&self) -> f64 {
  function estimate_bias (line 126) | fn estimate_bias(&self, estimate: f64) -> f64 {
  function merge_in (line 208) | pub fn merge_in(&mut self, other: &Storage<'_>) {
  function num_bytes (line 229) | pub fn num_bytes(&self) -> usize {
  function hash (line 247) | pub fn hash<V: Hash>(val: V) -> u64 {
  function new_panics_b3 (line 255) | fn new_panics_b3() {
  function new_works_b4 (line 260) | fn new_works_b4() {
  function new_works_b18 (line 265) | fn new_works_b18() {
  function new_panics_b19 (line 271) | fn new_panics_b19() {
  function empty (line 276) | fn empty() {
  function add_b4_n1k (line 281) | fn add_b4_n1k() {
  function add_b8_n1k (line 291) | fn add_b8_n1k() {
  function add_b12_n1k (line 301) | fn add_b12_n1k() {
  function add_b16_n1k (line 310) | fn add_b16_n1k() {
  function add_b8_n10k (line 319) | fn add_b8_n10k() {
  function add_b12_n10k (line 328) | fn add_b12_n10k() {
  function add_b16_n10k (line 337) | fn add_b16_n10k() {
  function add_b16_n100k (line 346) | fn add_b16_n100k() {
  function add_b16_n1m (line 355) | fn add_b16_n1m() {
  function clone (line 364) | fn clone() {
  function merge (line 383) | fn merge() {
  function merge_panics_p (line 404) | fn merge_panics_p() {
  function issue_74 (line 411) | fn issue_74() {
  function quick_16 (line 480) | fn quick_16(values: HashSet<u64>) -> quickcheck::TestResult {
  function quick_8 (line 499) | fn quick_8(values: Vec<u64>) -> quickcheck::TestResult {
  function quick_decode_16 (line 517) | fn quick_decode_16(value: u64) -> bool {

FILE: crates/hyperloglogplusplus/src/hyperloglog_data.rs
  constant THRESHOLD_DATA_OFFSET (line 6) | pub(crate) const THRESHOLD_DATA_OFFSET: usize = 4;
  constant THRESHOLD_DATA_VEC (line 7) | pub(crate) const THRESHOLD_DATA_VEC: &[usize] = &[
  constant RAW_ESTIMATE_DATA_OFFSET (line 25) | pub(crate) const RAW_ESTIMATE_DATA_OFFSET: usize = 4;
  constant RAW_ESTIMATE_DATA_VEC (line 26) | pub(crate) const RAW_ESTIMATE_DATA_VEC: &[&[f64]] = &[
  constant BIAS_DATA_OFFSET (line 1129) | pub(crate) const BIAS_DATA_OFFSET: usize = 4;
  constant BIAS_DATA_VEC (line 1130) | pub(crate) const BIAS_DATA_VEC: &[&[f64]] = &[

FILE: crates/hyperloglogplusplus/src/lib.rs
  type HyperLogLog (line 18) | pub struct HyperLogLog<'s, T: ?Sized, B> {
  type HyperLogLogStorage (line 25) | pub enum HyperLogLogStorage<'s> {
  function new (line 31) | pub fn new(precision: u8, buildhasher: B) -> Self {
  function from_sparse_parts (line 39) | pub fn from_sparse_parts(
  function from_dense_parts (line 56) | pub fn from_dense_parts(bytes: &'s [u8], precision: u8, buildhasher: B) ...
  function estimate_count (line 64) | pub fn estimate_count(&mut self) -> u64 {
  function immutable_estimate_count (line 73) | pub fn immutable_estimate_count(&self) -> u64 {
  function is_sparse (line 82) | pub fn is_sparse(&self) -> bool {
  function num_bytes (line 88) | pub fn num_bytes(&self) -> usize {
  function to_parts (line 97) | pub fn to_parts(&mut self) -> &HyperLogLogStorage<'s> {
  function merge_all (line 102) | pub fn merge_all(&mut self) {
  function into_owned (line 109) | pub fn into_owned(&self) -> HyperLogLog<'static, T, B>
  function add (line 131) | pub fn add(&mut self, value: &T) {
  function merge_in (line 147) | pub fn merge_in(&mut self, other: &HyperLogLog<'_, T, B>) {
  type Extractable (line 168) | pub(crate) trait Extractable:
    constant NUM_BITS (line 171) | const NUM_BITS: u8;
    method extract_bits (line 172) | fn extract_bits(&self, high: u8, low: u8) -> Self {
    method extract (line 175) | fn extract(&self, high: u8, len: u8) -> Self {
    method q (line 178) | fn q(&self) -> u8;
    constant NUM_BITS (line 182) | const NUM_BITS: u8 = 64;
    method q (line 183) | fn q(&self) -> u8 {
    constant NUM_BITS (line 189) | const NUM_BITS: u8 = 32;
    method q (line 190) | fn q(&self) -> u8 {
  function error_for_precision (line 195) | pub fn error_for_precision(precision: u8) -> f64 {
  function precision_for_error (line 199) | pub fn precision_for_error(max_error: f64) -> u8 {
  function test_asc_4_10k (line 222) | fn test_asc_4_10k() {
  function test_asc_4_100k (line 234) | fn test_asc_4_100k() {
  function test_asc_4_500k (line 246) | fn test_asc_4_500k() {
  function test_asc_8_10k (line 259) | fn test_asc_8_10k() {
  function test_asc_8_100k (line 271) | fn test_asc_8_100k() {
  function test_asc_8_500k (line 283) | fn test_asc_8_500k() {
  function test_asc_16_10k (line 296) | fn test_asc_16_10k() {
  function test_asc_16_100k (line 308) | fn test_asc_16_100k() {
  function test_asc_16_500k (line 320) | fn test_asc_16_500k() {
  function quick_hll_16 (line 333) | fn quick_hll_16(values: HashSet<u64>) -> TestResult {
  function quick_merge_hll_16 (line 352) | fn quick_merge_hll_16(values_a: Vec<u64>, values_b: Vec<u64>) {
  function quick_merge_hll_8 (line 374) | fn quick_merge_hll_8(values_a: Vec<u64>, values_b: Vec<u64>) {
  function quick_merge_hll_4 (line 402) | fn quick_merge_hll_4(values_a: Vec<u64>, values_b: Vec<u64>) {
  function precision_for_error (line 422) | fn precision_for_error() {

FILE: crates/hyperloglogplusplus/src/registers.rs
  type Registers (line 22) | pub struct Registers<'s>(Cow<'s, [u8]>);
  function new (line 26) | pub fn new(exponent: u8) -> Self {
  function from_raw (line 44) | pub fn from_raw(bytes: &'s [u8]) -> Self {
  function at (line 49) | pub fn at(&self, idx: usize) -> u8 {
  function set_max (line 59) | pub fn set_max(&mut self, idx: usize, value: u8) {
  function bytes (line 93) | pub fn bytes(&self) -> &[u8] {
  function count_zeroed_registers (line 97) | pub fn count_zeroed_registers(&self) -> u64 {
  function iter (line 101) | pub fn iter(&self) -> impl Iterator<Item = u8> + '_ {
  function byte_len (line 128) | pub fn byte_len(&self) -> usize {
  function merge (line 132) | pub fn merge(a: &Registers<'_>, b: &Registers<'_>) -> Self {
  function into_owned (line 150) | pub fn into_owned(&self) -> Registers<'static> {
  function test_last_index_not_clobbered (line 160) | fn test_last_index_not_clobbered() {
  function test_last_index_not_clobbers (line 186) | fn test_last_index_not_clobbers() {
  function test_count_empty (line 215) | fn test_count_empty() {
  function test_count_4 (line 220) | fn test_count_4() {
  function test_count_5 (line 226) | fn test_count_5() {
  function test_count_6 (line 232) | fn test_count_6() {
  function test_count_7 (line 238) | fn test_count_7() {
  function test_iter_4_0_1 (line 244) | fn test_iter_4_0_1() {
  function quick_test (line 254) | fn quick_test(exp: u8, ops: Vec<(usize, u8)>) -> quickcheck::TestResult {
  function quick_merge (line 309) | fn quick_merge(

FILE: crates/hyperloglogplusplus/src/sparse.rs
  type Storage (line 16) | pub struct Storage<'s> {
  type Encoded (line 25) | pub struct Encoded(u32);
    method from_hash (line 193) | pub(crate) fn from_hash(hash: u64, precision: u8) -> Self {
    method idx (line 211) | pub fn idx(&self) -> u32 {
    method count (line 219) | pub fn count(&self, p: u8) -> u8 {
    method stores_count (line 231) | fn stores_count(&self) -> bool {
    method extract_count (line 236) | fn extract_count(&self) -> u8 {
  constant NUM_HIGH_BITS (line 27) | const NUM_HIGH_BITS: u8 = 25;
  type Overflowing (line 29) | pub type Overflowing = bool;
  function new (line 32) | pub fn new(precision: u8) -> Self {
  function from_parts (line 46) | pub fn from_parts(bytes: &'s [u8], num_compressed: u64, precision: u8) -...
  function into_owned (line 60) | pub fn into_owned(&self) -> Storage<'static> {
  function add_hash (line 69) | pub fn add_hash(&mut self, hash: u64) -> Overflowing {
  function add_encoded (line 74) | fn add_encoded(&mut self, encoded: Encoded) -> Overflowing {
  function estimate_count (line 85) | pub fn estimate_count(&mut self) -> u64 {
  function immutable_estimate_count (line 90) | pub fn immutable_estimate_count(&self) -> u64 {
  function merge_buffers (line 100) | pub fn merge_buffers(&mut self) {
  function iter (line 149) | fn iter(&self) -> impl Iterator<Item = Encoded> + '_ {
  function to_dense (line 153) | pub fn to_dense(&mut self) -> dense::Storage<'static> {
  function immutable_to_dense (line 159) | pub fn immutable_to_dense(&self) -> dense::Storage<'static> {
  function num_bytes (line 170) | pub fn num_bytes(&self) -> usize {
  function merge_in (line 174) | pub fn merge_in(&mut self, other: &Storage<'_>) -> Overflowing {
  method partial_cmp (line 242) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
  method cmp (line 250) | fn cmp(&self, other: &Self) -> std::cmp::Ordering {
  constant NUM_HASH_BITS (line 273) | const NUM_HASH_BITS: u8 = 64 - NUM_HIGH_BITS;
  function hash (line 275) | pub fn hash(val: i32) -> u64 {
  function test_asc_10k (line 282) | fn test_asc_10k() {
  function test_asc_100k (line 291) | fn test_asc_100k() {
  function test_asc_500k (line 301) | fn test_asc_500k() {
  function quick_sparse (line 312) | fn quick_sparse(values: Vec<u64>) -> TestResult {
  function quick_sparse_as_set (line 334) | fn quick_sparse_as_set(values: Vec<u64>) -> TestResult {
  function quick_sparse_merge_invariant (line 371) | fn quick_sparse_merge_invariant(values: Vec<u64>) -> TestResult {
  function sparse_merge_01 (line 408) | fn sparse_merge_01() {

FILE: crates/hyperloglogplusplus/src/sparse/varint.rs
  function decompression_iter (line 7) | pub fn decompression_iter<'a>(
  type Compressed (line 16) | pub struct Compressed<'c>(Cow<'c, [u8]>);
  function from_raw (line 19) | pub fn from_raw(bytes: &'c [u8]) -> Self {
  function bytes (line 23) | pub fn bytes(&self) -> &[u8] {
  function num_bytes (line 27) | pub fn num_bytes(&self) -> usize {
  function cap (line 32) | pub fn cap(&self) -> usize {
  function make_owned (line 36) | pub fn make_owned(&self) -> Compressed<'static> {
  type Compressor (line 41) | pub struct Compressor<F: FnMut(u64) -> u64> {
  function compressor (line 48) | pub fn compressor() -> Compressor<impl FnMut(u64) -> u64> {
  function is_empty (line 57) | pub fn is_empty(&self) -> bool {
  function last_mut (line 61) | pub fn last_mut(&mut self) -> Option<&mut Encoded> {
  function push (line 65) | pub fn push(&mut self, value: Encoded) {
  function into_compressed (line 73) | pub fn into_compressed(mut self) -> (Compressed<'static>, u64) {
  function compress_value (line 84) | fn compress_value(&mut self, Encoded(value): Encoded) {
  function extend (line 91) | fn extend<T: IntoIterator<Item = Encoded>>(&mut self, iter: T) {
  function quick_test_roundtrip (line 103) | fn quick_test_roundtrip(values: Vec<u32>) -> bool {

FILE: crates/scripting-utilities/control_file_reader/src/lib.rs
  type Result (line 5) | pub type Result<T, E = Error> = std::result::Result<T, E>;
  function get_current_version (line 8) | pub fn get_current_version(control_file: &str) -> Result<String> {
  function get_upgradeable_from (line 13) | pub fn get_upgradeable_from(control_file: &str) -> Result<Vec<String>> {
  function get_field_val (line 24) | pub fn get_field_val<'a>(file: &'a str, field_name: &str) -> Result<&'a ...
  function get_quoted_field (line 34) | pub fn get_quoted_field(line: &str) -> Result<&str> {
  type Error (line 44) | pub enum Error {
    method fmt (line 51) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 61) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: crates/scripting-utilities/postgres_connection_configuration/src/lib.rs
  type ConnectionConfig (line 6) | pub struct ConnectionConfig<'s> {
  function with_db (line 15) | pub fn with_db<'d>(&self, database: &'d str) -> ConnectionConfig<'d>
  function config_string (line 26) | pub fn config_string(&self) -> String {

FILE: crates/stats-agg/src/lib.rs
  type FloatLike (line 10) | pub trait FloatLike:
    method lit (line 14) | fn lit(val: f64) -> Self {
    method from_u64 (line 17) | fn from_u64(n: u64) -> Self;
    method from_u64 (line 20) | fn from_u64(n: u64) -> Self {
    method from_u64 (line 25) | fn from_u64(n: u64) -> Self {
  type StatsError (line 31) | pub enum StatsError {
  type XYPair (line 36) | pub struct XYPair<T: FloatLike> {
  constant INV_FLOATING_ERROR_THRESHOLD (line 55) | const INV_FLOATING_ERROR_THRESHOLD: f64 = 0.99;
  constant INV_FLOATING_ERROR_THRESHOLD (line 57) | const INV_FLOATING_ERROR_THRESHOLD: f64 = f64::INFINITY;
  function accum (line 68) | pub(crate) fn accum<T: FloatLike>(n: T, sx: T, sxx: T, sx3: T, x: T) -> T {
  function remove (line 76) | pub(crate) fn remove<T: FloatLike>(new_n: T, new_sx: T, new_sxx: T, old_...
  function combine (line 85) | pub(crate) fn combine<T: FloatLike>(
  function remove_combined (line 104) | pub(crate) fn remove_combined<T: FloatLike>(
  function accum (line 129) | pub(crate) fn accum<T: FloatLike>(n: T, sx: T, sxx: T, sx3: T, sx4: T, x...
  function remove (line 138) | pub(crate) fn remove<T: FloatLike>(
  function combine (line 156) | pub(crate) fn combine<T: FloatLike>(
  function remove_combined (line 178) | pub(crate) fn remove_combined<T: FloatLike>(
  function floatlike_lit (line 208) | fn floatlike_lit() {

FILE: crates/stats-agg/src/stats1d.rs
  type StatsSummary1D (line 6) | pub struct StatsSummary1D<T: FloatLike> {
  method default (line 17) | fn default() -> Self {
  function from (line 24) | fn from(input_summary: StatsSummary1D<f64>) -> Self {
  function convert_tf_to_f64 (line 34) | pub fn convert_tf_to_f64(tf: TwoFloat) -> f64 {
  function from (line 38) | fn from(input_summary: StatsSummary1D<TwoFloat>) -> Self {
  function n64 (line 53) | fn n64(&self) -> T {
  function new (line 57) | pub fn new() -> Self {
  function accum (line 71) | pub fn accum(&mut self, p: T) -> Result<(), StatsError> {
  function has_infinite (line 112) | fn has_infinite(&self) -> bool {
  function check_overflow (line 119) | fn check_overflow(&self, old: &Self, p: T) -> bool {
  function remove (line 140) | pub fn remove(&self, p: T) -> Option<Self> {
  function new_from_vec (line 179) | pub fn new_from_vec(v: Vec<T>) -> Result<Self, StatsError> {
  function combine (line 187) | pub fn combine(&self, other: Self) -> Result<Self, StatsError> {
  function remove_combined (line 242) | pub fn remove_combined(&self, remove: Self) -> Option<Self> {
  function avg (line 292) | pub fn avg(&self) -> Option<T> {
  function count (line 299) | pub fn count(&self) -> i64 {
  function sum (line 303) | pub fn sum(&self) -> Option<T> {
  function var_pop (line 310) | pub fn var_pop(&self) -> Option<T> {
  function var_samp (line 317) | pub fn var_samp(&self) -> Option<T> {
  function stddev_pop (line 324) | pub fn stddev_pop(&self) -> Option<T> {
  function stddev_samp (line 328) | pub fn stddev_samp(&self) -> Option<T> {
  function skewness_pop (line 332) | pub fn skewness_pop(&self) -> Option<T> {
  function skewness_samp (line 336) | pub fn skewness_samp(&self) -> Option<T> {
  function kurtosis_pop (line 340) | pub fn kurtosis_pop(&self) -> Option<T> {
  function kurtosis_samp (line 344) | pub fn kurtosis_samp(&self) -> Option<T> {
  function tf (line 354) | fn tf(f: f64) -> TwoFloat {
  function assert_close_enough (line 359) | fn assert_close_enough(s1: &StatsSummary1D<f64>, s2: &StatsSummary1D<f64...
  function assert_close_enough_tf (line 368) | fn assert_close_enough_tf(s1: &StatsSummary1D<TwoFloat>, s2: &StatsSumma...
  function test_against_known_vals (line 377) | fn test_against_known_vals() {
  function test_against_known_vals_tf (line 416) | fn test_against_known_vals_tf() {
  function test_combine (line 486) | fn test_combine() {

FILE: crates/stats-agg/src/stats2d.rs
  type StatsSummary2D (line 11) | pub struct StatsSummary2D<T: FloatLike> {
  function from (line 25) | fn from(input_summary: StatsSummary2D<TwoFloat>) -> Self {
  method default (line 42) | fn default() -> Self {
  function new (line 48) | pub fn new() -> Self {
  function n64 (line 63) | fn n64(&self) -> T {
  function accum (line 81) | pub fn accum(&mut self, p: XYPair<T>) -> Result<(), StatsError> {
  function has_infinite (line 145) | fn has_infinite(&self) -> bool {
  function check_overflow (line 156) | fn check_overflow(&self, old: &StatsSummary2D<T>, p: XYPair<T>) -> bool {
  function remove (line 194) | pub fn remove(&self, p: XYPair<T>) -> Option<Self> {
  function new_from_vec (line 253) | pub fn new_from_vec(v: Vec<XYPair<T>>) -> Result<Self, StatsError> {
  function combine (line 276) | pub fn combine(&self, other: StatsSummary2D<T>) -> Result<Self, StatsErr...
  function remove_combined (line 354) | pub fn remove_combined(&self, remove: StatsSummary2D<T>) -> Option<Self> {
  function offset (line 450) | pub fn offset(&mut self, offset: XYPair<T>) -> Result<(), StatsError> {
  function sum_squares (line 475) | pub fn sum_squares(&self) -> Option<XYPair<T>> {
  function sumxy (line 494) | pub fn sumxy(&self) -> Option<T> {
  function avg (line 513) | pub fn avg(&self) -> Option<XYPair<T>> {
  function count (line 534) | pub fn count(&self) -> i64 {
  function sum (line 550) | pub fn sum(&self) -> Option<XYPair<T>> {
  function var_pop (line 560) | pub fn var_pop(&self) -> Option<XYPair<T>> {
  function var_samp (line 570) | pub fn var_samp(&self) -> Option<XYPair<T>> {
  function stddev_pop (line 581) | pub fn stddev_pop(&self) -> Option<XYPair<T>> {
  function stddev_samp (line 590) | pub fn stddev_samp(&self) -> Option<XYPair<T>> {
  function skewness_pop (line 598) | pub fn skewness_pop(&self) -> Option<XYPair<T>> {
  function skewness_samp (line 606) | pub fn skewness_samp(&self) -> Option<XYPair<T>> {
  function kurtosis_pop (line 614) | pub fn kurtosis_pop(&self) -> Option<XYPair<T>> {
  function kurtosis_samp (line 622) | pub fn kurtosis_samp(&self) -> Option<XYPair<T>> {
  function corr (line 634) | pub fn corr(&self) -> Option<T> {
  function slope (line 643) | pub fn slope(&self) -> Option<T> {
  function intercept (line 653) | pub fn intercept(&self) -> Option<T> {
  function x_intercept (line 664) | pub fn x_intercept(&self) -> Option<T> {
  function determination_coeff (line 677) | pub fn determination_coeff(&self) -> Option<T> {
  function covar_samp (line 699) | pub fn covar_samp(&self) -> Option<T> {
  function covar_pop (line 717) | pub fn covar_pop(&self) -> Option<T> {
  function tf (line 728) | fn tf(f: f64) -> TwoFloat {
  function test_linear (line 733) | fn test_linear() {
  function test_linear_tf (line 785) | fn test_linear_tf() {

FILE: crates/stats-agg/src/stats2d/stats2d_flat_serialize.rs
  constant REQUIRED_ALIGNMENT (line 6) | const REQUIRED_ALIGNMENT: usize = {
  constant MAX_PROVIDED_ALIGNMENT (line 51) | const MAX_PROVIDED_ALIGNMENT: Option<usize> = {
  constant MIN_LEN (line 140) | const MIN_LEN: usize = {
  constant TRIVIAL_COPY (line 155) | const TRIVIAL_COPY: bool = true;
  type SLICE (line 156) | type SLICE = flat_serialize::Slice<'a, StatsSummary2D<f64>>;
  type OWNED (line 157) | type OWNED = Self;
  function try_ref (line 160) | unsafe fn try_ref(mut input: &[u8]) -> Result<(Self, &[u8]), flat_serial...
  function fill_slice (line 335) | unsafe fn fill_slice<'out>(
  function num_bytes (line 394) | fn num_bytes(&self) -> usize {
  function make_owned (line 420) | fn make_owned(&mut self) {}
  function into_owned (line 422) | fn into_owned(self) -> Self::OWNED {

FILE: crates/t-digest-lib/src/lib.rs
  function timescaledb_toolkit_tdigest_builder_with_size (line 5) | pub extern "C" fn timescaledb_toolkit_tdigest_builder_with_size(
  function timescaledb_toolkit_tdigest_push (line 12) | pub unsafe extern "C" fn timescaledb_toolkit_tdigest_push(
  function timescaledb_toolkit_tdigest_merge (line 21) | pub unsafe extern "C" fn timescaledb_toolkit_tdigest_merge(
  function timescaledb_toolkit_tdigest_builder_free (line 30) | pub extern "C" fn timescaledb_toolkit_tdigest_builder_free(_: Box<tdiges...
  function timescaledb_toolkit_tdigest_build (line 33) | pub extern "C" fn timescaledb_toolkit_tdigest_build(
  function timescaledb_toolkit_tdigest_free (line 40) | pub extern "C" fn timescaledb_toolkit_tdigest_free(_: Box<tdigest::TDige...
  function timescaledb_toolkit_tdigest_format_for_postgres (line 47) | pub unsafe extern "C" fn timescaledb_toolkit_tdigest_format_for_postgres(

FILE: crates/t-digest/src/lib.rs
  type Centroid (line 52) | pub struct Centroid {
    method new (line 70) | pub fn new(mean: f64, weight: u64) -> Self {
    method mean (line 78) | pub fn mean(&self) -> f64 {
    method weight (line 83) | pub fn weight(&self) -> u64 {
    method add (line 87) | pub fn add(&mut self, sum: f64, weight: u64) -> f64 {
  method partial_cmp (line 58) | fn partial_cmp(&self, other: &Centroid) -> Option<Ordering> {
  method cmp (line 64) | fn cmp(&self, other: &Centroid) -> Ordering {
  method default (line 100) | fn default() -> Self {
  type TDigest (line 110) | pub struct TDigest {
    method new_with_size (line 120) | pub fn new_with_size(max_size: usize) -> Self {
    method new (line 131) | pub fn new(
    method raw_centroids (line 159) | pub fn raw_centroids(&self) -> &[Centroid] {
    method mean (line 164) | pub fn mean(&self) -> f64 {
    method sum (line 175) | pub fn sum(&self) -> f64 {
    method count (line 180) | pub fn count(&self) -> u64 {
    method max (line 185) | pub fn max(&self) -> f64 {
    method min (line 190) | pub fn min(&self) -> f64 {
    method is_empty (line 195) | pub fn is_empty(&self) -> bool {
    method max_size (line 200) | pub fn max_size(&self) -> usize {
    method num_buckets (line 205) | pub fn num_buckets(&self) -> usize {
    method format_for_postgres (line 209) | pub fn format_for_postgres(&self) -> String {
    method k_to_q (line 253) | fn k_to_q(k: f64, d: f64) -> f64 {
    method merge_unsorted (line 263) | pub fn merge_unsorted(&self, unsorted_values: Vec<f64>) -> TDigest {
    method update_bounds_on_overflow (line 275) | fn update_bounds_on_overflow(
    method merge_sorted (line 288) | pub fn merge_sorted(&self, sorted_values: Vec<f64>) -> TDigest {
    method external_merge (line 379) | fn external_merge(centroids: &mut [Centroid], first: usize, middle: us...
    method merge_digests (line 420) | pub fn merge_digests(digests: Vec<TDigest>) -> TDigest {
    method estimate_quantile_at_value (line 518) | pub fn estimate_quantile_at_value(&self, v: f64) -> f64 {
    method estimate_quantile (line 563) | pub fn estimate_quantile(&self, q: f64) -> f64 {
  method default (line 240) | fn default() -> Self {
  type Builder (line 684) | pub struct Builder {
    method from (line 691) | fn from(digested: TDigest) -> Self {
    method with_size (line 700) | pub fn with_size(size: usize) -> Self {
    method push (line 706) | pub fn push(&mut self, value: f64) {
    method digest (line 714) | fn digest(&mut self) {
    method build (line 722) | pub fn build(&mut self) -> TDigest {
    method merge (line 727) | pub fn merge(&mut self, other: Self) {
  function test_centroid_addition_regression (line 745) | fn test_centroid_addition_regression() {
  function test_merge_sorted_against_uniform_distro (line 767) | fn test_merge_sorted_against_uniform_distro() {
  function test_merge_unsorted_against_uniform_distro (line 805) | fn test_merge_unsorted_against_uniform_distro() {
  function test_merge_sorted_against_skewed_distro (line 843) | fn test_merge_sorted_against_skewed_distro() {
  function test_merge_unsorted_against_skewed_distro (line 869) | fn test_merge_unsorted_against_skewed_distro() {
  function test_merge_digests (line 895) | fn test_merge_digests() {
  function test_quantile_and_value_estimates (line 939) | fn test_quantile_and_value_estimates() {
  function test_buffered_merge (line 978) | fn test_buffered_merge() {
  type OrderedF64 (line 998) | struct OrderedF64(OrderedFloat<f64>);
  method arbitrary (line 1001) | fn arbitrary(g: &mut Gen) -> Self {
  function fuzzing_test (line 1007) | fn fuzzing_test(

FILE: crates/time-weighted-average/src/lib.rs
  type TimeWeightMethod (line 8) | pub enum TimeWeightMethod {
    method interpolate (line 205) | pub fn interpolate(
    method weighted_sum (line 232) | pub fn weighted_sum(&self, first: TSPoint, second: TSPoint) -> f64 {
  type TimeWeightSummary (line 14) | pub struct TimeWeightSummary {
    method new (line 32) | pub fn new(pt: TSPoint, method: TimeWeightMethod) -> Self {
    method accum (line 41) | pub fn accum(&mut self, pt: TSPoint) -> Result<(), TimeWeightError> {
    method combine (line 60) | pub fn combine(&self, next: &TimeWeightSummary) -> Result<TimeWeightSu...
    method new_from_sorted_iter (line 79) | pub fn new_from_sorted_iter<'a>(
    method combine_sorted_iter (line 96) | pub fn combine_sorted_iter<'a>(
    method with_bounds (line 121) | pub fn with_bounds(
    method with_prev (line 137) | fn with_prev(&self, target_start: i64, prev: TSPoint) -> Result<Self, ...
    method with_next (line 158) | fn with_next(&self, target_end: i64, next: Option<TSPoint>) -> Result<...
    method time_weighted_average (line 185) | pub fn time_weighted_average(&self) -> Result<f64, TimeWeightError> {
    method time_weighted_integral (line 194) | pub fn time_weighted_integral(&self) -> f64 {
  type TimeWeightError (line 22) | pub enum TimeWeightError {
  function test_simple_accum_locf (line 263) | fn test_simple_accum_locf() {
  function test_simple_accum_linear (line 278) | fn test_simple_accum_linear() {
  function new_from_sorted_iter_test (line 293) | fn new_from_sorted_iter_test(t: TimeWeightMethod) {
  function test_new_from_sorted_iter (line 324) | fn test_new_from_sorted_iter() {
  function combine_test (line 329) | fn combine_test(t: TimeWeightMethod) {
  function test_combine (line 358) | fn test_combine() {
  function order_accum_test (line 363) | fn order_accum_test(t: TimeWeightMethod) {
  function test_order_accum (line 418) | fn test_order_accum() {
  function order_combine_test (line 423) | fn order_combine_test(t: TimeWeightMethod) {
  function test_order_combine (line 445) | fn test_order_combine() {
  function combine_sorted_iter_test (line 450) | fn combine_sorted_iter_test(t: TimeWeightMethod) {
  function test_combine_sorted_iter (line 505) | fn test_combine_sorted_iter() {
  function test_mismatch_combine (line 511) | fn test_mismatch_combine() {
  function test_weighted_sum (line 538) | fn test_weighted_sum() {
  function with_prev_common_test (line 557) | fn with_prev_common_test(t: TimeWeightMethod) {
  function test_with_prev (line 608) | fn test_with_prev() {
  function with_next_common_test (line 654) | fn with_next_common_test(t: TimeWeightMethod) {
  function test_with_next (line 708) | fn test_with_next() {
  function average_common_tests (line 762) | fn average_common_tests(t: TimeWeightMethod) {
  function test_average (line 770) | fn test_average() {

FILE: crates/tspoint/src/lib.rs
  type TSPoint (line 9) | pub struct TSPoint {
    method interpolate_linear (line 20) | pub fn interpolate_linear(&self, p2: &TSPoint, ts: i64) -> Result<f64,...
    method deserialize (line 62) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type TSPointError (line 15) | pub enum TSPointError {
  method serialize (line 32) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function test_linear_interpolate (line 157) | fn test_linear_interpolate() {

FILE: crates/udd-sketch/src/lib.rs
  type SketchHashKey (line 25) | pub enum SketchHashKey {
    method cmp (line 34) | fn cmp(&self, other: &Self) -> std::cmp::Ordering {
    method partial_cmp (line 53) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
    method compact_key (line 71) | fn compact_key(&self) -> SketchHashKey {
  type UDDSketchMetadata (line 60) | pub struct UDDSketchMetadata {
  type SketchHashEntry (line 86) | struct SketchHashEntry {
  type SketchHashMap (line 93) | struct SketchHashMap {
    type Output (line 99) | type Output = u64;
    method index (line 101) | fn index(&self, id: SketchHashKey) -> &Self::Output {
    method new (line 128) | fn new() -> SketchHashMap {
    method with_capacity (line 135) | fn with_capacity(capacity: usize) -> SketchHashMap {
    method increment (line 143) | fn increment(&mut self, key: SketchHashKey) {
    method iter (line 147) | fn iter(&self) -> SketchHashIterator<'_> {
    method entry_split (line 158) | fn entry_split(&mut self, key: SketchHashKey) -> SketchHashKey {
    method entry_upsert (line 192) | fn entry_upsert(&mut self, key: SketchHashKey, count: u64) {
    method len (line 222) | fn len(&self) -> usize {
    method compact_using_stack (line 227) | fn compact_using_stack<const N: usize>(&mut self) {
    method populate_map_using_iter (line 249) | fn populate_map_using_iter(&mut self, entries: &mut [(SketchHashKey, u...
    method compact (line 305) | fn compact(&mut self) {
    method compact_using_heap (line 318) | fn compact_using_heap(&mut self) {
  type SketchHashIterator (line 108) | pub struct SketchHashIterator<'a> {
  type Item (line 114) | type Item = (SketchHashKey, u64);
  method next (line 116) | fn next(&mut self) -> Option<(SketchHashKey, u64)> {
  type UDDSketch (line 329) | pub struct UDDSketch {
    method new (line 340) | pub fn new(max_buckets: u32, initial_error: f64) -> Self {
    method new_from_data (line 355) | pub fn new_from_data(
    method key (line 393) | fn key(&self, value: f64) -> SketchHashKey {
    method compact_buckets (line 397) | pub fn compact_buckets(&mut self) {
    method bucket_iter (line 405) | pub fn bucket_iter(&self) -> SketchHashIterator<'_> {
    method add_value (line 411) | pub fn add_value(&mut self, value: f64) {
    method merge_items (line 425) | pub fn merge_items(
    method merge_sketch (line 468) | pub fn merge_sketch(&mut self, other: &UDDSketch) {
    method max_allowed_buckets (line 512) | pub fn max_allowed_buckets(&self) -> u32 {
    method times_compacted (line 516) | pub fn times_compacted(&self) -> u8 {
    method current_buckets_count (line 520) | pub fn current_buckets_count(&self) -> usize {
    method mean (line 527) | pub fn mean(&self) -> f64 {
    method sum (line 536) | pub fn sum(&self) -> f64 {
    method count (line 541) | pub fn count(&self) -> u64 {
    method max_error (line 546) | pub fn max_error(&self) -> f64 {
    method estimate_quantile (line 550) | pub fn estimate_quantile(&self, quantile: f64) -> f64 {
    method estimate_quantile_at_value (line 560) | pub fn estimate_quantile_at_value(&self, value: f64) -> f64 {
  function estimate_quantile (line 565) | pub fn estimate_quantile(
  function last_bucket_value (line 592) | fn last_bucket_value(
  function bucket_to_value (line 602) | fn bucket_to_value(alpha: f64, gamma: f64, bucket: SketchHashKey) -> f64 {
  function estimate_quantile_at_value (line 612) | pub fn estimate_quantile_at_value(
  function key (line 637) | fn key(value: f64, gamma: f64) -> SketchHashKey {
  function gamma (line 650) | pub fn gamma(alpha: f64) -> f64 {
  function build_and_add_values (line 661) | fn build_and_add_values() {
  function exceed_buckets (line 673) | fn exceed_buckets() {
  function merge_verifier (line 699) | fn merge_verifier(sketch: &mut UDDSketch, other: &UDDSketch) {
  function merge_sketches (line 727) | fn merge_sketches() {
  function test_quantile_and_value_estimates (line 802) | fn test_quantile_and_value_estimates() {
  function test_extreme_quantile_at_value (line 842) | fn test_extreme_quantile_at_value() {
  function random_stress (line 857) | fn random_stress() {
  type OrderedF64 (line 893) | struct OrderedF64(OrderedFloat<f64>);
  method arbitrary (line 896) | fn arbitrary(g: &mut Gen) -> Self {
  function test_entry_invalid_hashmap_key (line 903) | fn test_entry_invalid_hashmap_key() {
  function test_entry_insertion_order (line 913) | fn test_entry_insertion_order() {
  function fuzzing_test (line 971) | fn fuzzing_test(

FILE: docs/examples/tdigest.c
  type TDigestBuilder (line 10) | struct TDigestBuilder
  type TDigest (line 11) | struct TDigest
  type TDigestBuilder (line 17) | struct TDigestBuilder
  type TDigestBuilder (line 21) | struct TDigestBuilder
  type TDigestBuilder (line 24) | struct TDigestBuilder
  type TDigestBuilder (line 24) | struct TDigestBuilder
  type TDigestBuilder (line 29) | struct TDigestBuilder
  type TDigest (line 33) | struct TDigest
  type TDigestBuilder (line 34) | struct TDigestBuilder
  type TDigest (line 38) | struct TDigest
  type TDigest (line 44) | struct TDigest
  function main (line 51) | int

FILE: docs/examples/tdigest.py
  class TDigest (line 21) | class TDigest:
    class Builder (line 23) | class Builder:
      method __init__ (line 24) | def __init__(self, pointer):
      method __enter__ (line 27) | def __enter__(self):
      method __exit__ (line 31) | def __exit__(self, exc_type, exc_val, exc_tb):
      method __del__ (line 37) | def __del__(self):
      method with_size (line 41) | def with_size(size):
      method push (line 44) | def push(self, value):
      method build (line 47) | def build(self):
    method __init__ (line 53) | def __init__(self, pointer):
    method __enter__ (line 56) | def __enter__(self):
    method __exit__ (line 60) | def __exit__(self, exc_type, exc_val, exc_tb):
    method __del__ (line 66) | def __del__(self):
    method format_for_postgres (line 70) | def format_for_postgres(self):
  function test (line 78) | def test():

FILE: extension/src/accessors.rs
  function accessor_live_at (line 121) | pub fn accessor_live_at(ts: crate::raw::TimestampTz) -> AccessorLiveAt {
  function accessor_stddev (line 142) | pub fn accessor_stddev(method: default!(&str, "'sample'")) -> AccessorSt...
  function accessor_stddev_x (line 164) | pub fn accessor_stddev_x(method: default!(&str, "'sample'")) -> Accessor...
  function accessor_stddev_y (line 186) | pub fn accessor_stddev_y(method: default!(&str, "'sample'")) -> Accessor...
  function accessor_variance (line 208) | pub fn accessor_variance(method: default!(&str, "'sample'")) -> Accessor...
  function accessor_variance_x (line 230) | pub fn accessor_variance_x(method: default!(&str, "'sample'")) -> Access...
  function accessor_variance_y (line 252) | pub fn accessor_variance_y(method: default!(&str, "'sample'")) -> Access...
  function accessor_skewness (line 274) | pub fn accessor_skewness(method: default!(&str, "'sample'")) -> Accessor...
  function accessor_skewness_x (line 296) | pub fn accessor_skewness_x(method: default!(&str, "'sample'")) -> Access...
  function accessor_skewness_y (line 318) | pub fn accessor_skewness_y(method: default!(&str, "'sample'")) -> Access...
  function accessor_kurtosis (line 340) | pub fn accessor_kurtosis(method: default!(&str, "'sample'")) -> Accessor...
  function accessor_kurtosis_x (line 362) | pub fn accessor_kurtosis_x(method: default!(&str, "'sample'")) -> Access...
  function accessor_kurtosis_y (line 384) | pub fn accessor_kurtosis_y(method: default!(&str, "'sample'")) -> Access...
  function accessor_covar (line 406) | pub fn accessor_covar(method: default!(&str, "'sample'")) -> AccessorCov...
  function accessor_extrapolated_delta (line 428) | pub fn accessor_extrapolated_delta(method: &str) -> AccessorExtrapolated...
  function accessor_extrapolated_rate (line 450) | pub fn accessor_extrapolated_rate(method: &str) -> AccessorExtrapolatedR...
  function accessor_with_bounds (line 475) | pub fn accessor_with_bounds(bounds: crate::raw::tstzrange) -> AccessorWi...
  method bounds (line 503) | pub fn bounds(&self) -> Option<I64Range> {
  function accessor_unnest (line 527) | pub fn accessor_unnest() -> AccessorUnnest {
  function accessor_integral (line 546) | pub fn accessor_integral(unit: default!(&str, "'second'")) -> AccessorIn...
  function accessor_topn_count (line 579) | pub fn accessor_topn_count(count: i64) -> AccessorTopNCount {
  function accessor_max_frequency_int (line 599) | pub fn accessor_max_frequency_int(value: i64) -> AccessorMaxFrequencyInt {
  function accessor_min_frequency_int (line 619) | pub fn accessor_min_frequency_int(value: i64) -> AccessorMinFrequencyInt {
  function accessor_percentiles (line 640) | pub fn accessor_percentiles(unit: Vec<f64>) -> AccessorPercentileArray {

FILE: extension/src/accessors/tests.rs
  function one_field_works (line 12) | fn one_field_works() {
  function two_field_works (line 18) | fn two_field_works() {

FILE: extension/src/aggregate_builder_tests.rs
  type State (line 19) | type State = String;
  function transition (line 21) | fn transition(state: Option<State>, #[sql_type("text")] value: String) -...
  function finally (line 25) | fn finally(state: Option<&mut State>) -> Option<String> {
  type State (line 32) | type State = String;
  function transition (line 34) | fn transition(state: Option<State>, #[sql_type("text")] value: String) -...
  function finally (line 38) | fn finally(state: Option<&mut State>) -> Option<String> {
  function serialize (line 42) | fn serialize(state: &State) -> bytea {
  function deserialize (line 46) | fn deserialize(bytes: bytea) -> State {
  function combine (line 50) | fn combine(a: Option<&State>, b: Option<&State>) -> Option<State> {
  type State (line 57) | type State = String;
  function transition (line 59) | fn transition(state: Option<State>, #[sql_type("text")] value: String) -...
  function finally (line 63) | fn finally(state: Option<&mut State>) -> Option<String> {
  constant PARALLEL_SAFE (line 67) | const PARALLEL_SAFE: bool = true;
  function serialize (line 69) | fn serialize(state: &State) -> bytea {
  function deserialize (line 73) | fn deserialize(bytes: bytea) -> State {
  function combine (line 77) | fn combine(a: Option<&State>, b: Option<&State>) -> Option<State> {
  function test_anything_in_experimental_and_returns_first (line 89) | fn test_anything_in_experimental_and_returns_first() {
  function test_anything_has_correct_fn_names_and_def (line 107) | fn test_anything_has_correct_fn_names_and_def() {
  function test_cagg_anything_has_correct_fn_names_and_def (line 135) | fn test_cagg_anything_has_correct_fn_names_and_def() {
  function test_parallel_anything_has_correct_fn_names_and_def (line 163) | fn test_parallel_anything_has_correct_fn_names_and_def() {
  function get_aggregate_spec (line 193) | fn get_aggregate_spec(client: &mut spi::SpiClient, aggregate_name: &str)...

FILE: extension/src/aggregate_utils.rs
  function get_collation (line 6) | pub unsafe fn get_collation(fcinfo: pg_sys::FunctionCallInfo) -> Option<...
  function get_collation_or_default (line 14) | pub fn get_collation_or_default(fcinfo: pg_sys::FunctionCallInfo) -> Opt...
  function in_aggregate_context (line 22) | pub unsafe fn in_aggregate_context<T, F: FnOnce() -> T>(
  function aggregate_mctx (line 31) | pub unsafe fn aggregate_mctx(fcinfo: pg_sys::FunctionCallInfo) -> Option...

FILE: extension/src/asap.rs
  type ASAPTransState (line 16) | pub struct ASAPTransState {
    method add_point (line 66) | fn add_point(&mut self, point: TSPoint) {
  function asap_trans (line 23) | pub fn asap_trans(
  function asap_trans_internal (line 32) | pub fn asap_trans_internal(
  function asap_final (line 77) | fn asap_final(
  function asap_final_inner (line 83) | fn asap_final_inner(
  function asap_on_timevector (line 136) | pub fn asap_on_timevector(
  function test_against_reference (line 202) | fn test_against_reference() {
  function test_asap_equivalence (line 273) | fn test_asap_equivalence() {

FILE: extension/src/candlestick.rs
  method new (line 40) | pub fn new(ts: i64, open: f64, high: f64, low: f64, close: f64, volume: ...
  method from_tick (line 63) | pub fn from_tick(ts: i64, price: f64, volume: Option<f64>) -> Self {
  method add_tick_data (line 67) | pub fn add_tick_data(&mut self, ts: i64, price: f64, volume: Option<f64>) {
  method combine (line 94) | pub fn combine(&mut self, candlestick: &Candlestick) {
  method open (line 131) | pub fn open(&self) -> f64 {
  method high (line 135) | pub fn high(&self) -> f64 {
  method low (line 139) | pub fn low(&self) -> f64 {
  method close (line 143) | pub fn close(&self) -> f64 {
  method open_time (line 147) | pub fn open_time(&self) -> i64 {
  method high_time (line 151) | pub fn high_time(&self) -> i64 {
  method low_time (line 155) | pub fn low_time(&self) -> i64 {
  method close_time (line 159) | pub fn close_time(&self) -> i64 {
  method volume (line 163) | pub fn volume(&self) -> Option<f64> {
  method vwap (line 170) | pub fn vwap(&self) -> Option<f64> {
  function candlestick (line 187) | pub fn candlestick(
  function tick_data_no_vol_transition (line 209) | pub fn tick_data_no_vol_transition(
  function tick_data_transition (line 219) | pub fn tick_data_transition(
  function tick_data_transition_inner (line 229) | pub fn tick_data_transition_inner(
  function candlestick_rollup_trans (line 257) | pub fn candlestick_rollup_trans(
  function candlestick_rollup_trans_inner (line 265) | pub fn candlestick_rollup_trans_inner(
  function candlestick_final (line 284) | pub fn candlestick_final(state: Internal, fcinfo: pg_sys::FunctionCallIn...
  function candlestick_final_inner (line 288) | pub fn candlestick_final_inner(
  function candlestick_combine (line 304) | pub fn candlestick_combine(
  function candlestick_combine_inner (line 312) | pub fn candlestick_combine_inner(
  function candlestick_serialize (line 331) | pub fn candlestick_serialize(state: Internal) -> bytea {
  function candlestick_deserialize (line 339) | pub fn candlestick_deserialize(bytes: bytea, _internal: Internal) -> Opt...
  function candlestick_deserialize_inner (line 343) | pub fn candlestick_deserialize_inner(bytes: bytea) -> Inner<Candlestick> {
  function arrow_open (line 399) | pub fn arrow_open(candlestick: Option<Candlestick>, _accessor: AccessorO...
  function open (line 404) | pub fn open(candlestick: Option<Candlestick>) -> Option<f64> {
  function arrow_high (line 410) | pub fn arrow_high(candlestick: Option<Candlestick>, _accessor: AccessorH...
  function high (line 415) | pub fn high(candlestick: Option<Candlestick>) -> Option<f64> {
  function arrow_low (line 421) | pub fn arrow_low(candlestick: Option<Candlestick>, _accessor: AccessorLo...
  function low (line 426) | pub fn low(candlestick: Option<Candlestick>) -> Option<f64> {
  function arrow_close (line 432) | pub fn arrow_close(candlestick: Option<Candlestick>, _accessor: Accessor...
  function close (line 437) | pub fn close(candlestick: Option<Candlestick>) -> Option<f64> {
  function arrow_open_time (line 443) | pub fn arrow_open_time(
  function open_time (line 451) | pub fn open_time(candlestick: Option<Candlestick>) -> Option<crate::raw:...
  function arrow_high_time (line 457) | pub fn arrow_high_time(
  function high_time (line 465) | pub fn high_time(candlestick: Option<Candlestick>) -> Option<crate::raw:...
  function arrow_low_time (line 471) | pub fn arrow_low_time(
  function low_time (line 479) | pub fn low_time(candlestick: Option<Candlestick>) -> Option<crate::raw::...
  function arrow_close_time (line 485) | pub fn arrow_close_time(
  function close_time (line 493) | pub fn close_time(candlestick: Option<Candlestick>) -> Option<crate::raw...
  function volume (line 498) | pub fn volume(candlestick: Option<Candlestick>) -> Option<f64> {
  function vwap (line 506) | pub fn vwap(candlestick: Option<Candlestick>) -> Option<f64> {
  function candlestick_single_point (line 543) | fn candlestick_single_point() {
  function candlestick_agg_single_point (line 567) | fn candlestick_agg_single_point() {
  function candlestick_accessors (line 591) | fn candlestick_accessors() {
  function candlestick_agg_accessors (line 646) | fn candlestick_agg_accessors() {
  function candlestick_agg_extreme_values (line 684) | fn candlestick_agg_extreme_values() {
  function candlestick_null_inputs (line 735) | fn candlestick_null_inputs() {
  function candlestick_agg_null_inputs (line 753) | fn candlestick_agg_null_inputs() {
  function candlestick_as_constructor (line 787) | fn candlestick_as_constructor() {
  function candlestick_agg_constant (line 831) | fn candlestick_agg_constant() {
  function candlestick_agg_strictly_increasing (line 861) | fn candlestick_agg_strictly_increasing() {
  function candlestick_agg_strictly_decreasing (line 891) | fn candlestick_agg_strictly_decreasing() {
  function candlestick_agg_oscillating (line 921) | fn candlestick_agg_oscillating() {
  function candlestick_rollup (line 958) | fn candlestick_rollup() {
  function candlestick_agg_rollup (line 989) | fn candlestick_agg_rollup() {
  function candlestick_byte_io (line 1030) | fn candlestick_byte_io() {

FILE: extension/src/counter_agg.rs
  type PgTypeHackStatsSummary2D (line 37) | type PgTypeHackStatsSummary2D = StatsSummary2D<f64>;
  method to_internal_counter_summary (line 58) | pub fn to_internal_counter_summary(&self) -> MetricSummary {
  method from_internal_counter_summary (line 71) | pub fn from_internal_counter_summary(st: MetricSummary) -> Self {
  method interpolate (line 89) | fn interpolate(
  type CounterSummaryTransState (line 154) | pub struct CounterSummaryTransState {
    method new (line 166) | fn new() -> Self {
    method push_point (line 174) | fn push_point(&mut self, value: TSPoint) {
    method combine_points (line 182) | fn combine_points(&mut self) {
    method push_summary (line 203) | fn push_summary(&mut self, other: &CounterSummaryTransState) {
    method combine_summaries (line 210) | fn combine_summaries(&mut self) {
  function counter_summary_trans_serialize (line 230) | pub fn counter_summary_trans_serialize(state: Internal) -> bytea {
  function counter_summary_trans_deserialize (line 238) | pub fn counter_summary_trans_deserialize(bytes: bytea, _internal: Intern...
  function counter_summary_trans_deserialize_inner (line 241) | pub fn counter_summary_trans_deserialize_inner(bytes: bytea) -> Inner<Co...
  function counter_agg_trans (line 247) | pub fn counter_agg_trans(
  function counter_agg_trans_inner (line 256) | pub fn counter_agg_trans_inner(
  function counter_agg_trans_no_bounds (line 289) | pub fn counter_agg_trans_no_bounds(
  function counter_agg_summary_trans (line 299) | pub fn counter_agg_summary_trans(
  function counter_agg_summary_trans_inner (line 306) | pub fn counter_agg_summary_trans_inner(
  function counter_agg_combine (line 332) | pub fn counter_agg_combine(
  function counter_agg_combine_inner (line 339) | pub fn counter_agg_combine_inner(
  function counter_agg_final (line 372) | fn counter_agg_final(state: Internal, fcinfo: pg_sys::FunctionCallInfo) ...
  function counter_agg_final_inner (line 375) | fn counter_agg_final_inner(
  function arrow_counter_agg_delta (line 472) | pub fn arrow_counter_agg_delta(sketch: CounterSummary, _accessor: Access...
  function counter_agg_delta (line 477) | fn counter_agg_delta(summary: CounterSummary) -> f64 {
  function arrow_counter_agg_rate (line 483) | pub fn arrow_counter_agg_rate(sketch: CounterSummary, _accessor: Accesso...
  function counter_agg_rate (line 488) | fn counter_agg_rate(summary: CounterSummary) -> Option<f64> {
  function arrow_counter_agg_time_delta (line 494) | pub fn arrow_counter_agg_time_delta(sketch: CounterSummary, _accessor: A...
  function counter_agg_time_delta (line 499) | fn counter_agg_time_delta(summary: CounterSummary) -> f64 {
  function arrow_counter_agg_irate_left (line 505) | pub fn arrow_counter_agg_irate_left(
  function counter_agg_irate_left (line 513) | fn counter_agg_irate_left(summary: CounterSummary) -> Option<f64> {
  function arrow_counter_agg_irate_right (line 519) | pub fn arrow_counter_agg_irate_right(
  function counter_agg_irate_right (line 527) | fn counter_agg_irate_right(summary: CounterSummary) -> Option<f64> {
  function arrow_counter_agg_idelta_left (line 533) | pub fn arrow_counter_agg_idelta_left(sketch: CounterSummary, _accessor: ...
  function counter_agg_idelta_left (line 538) | fn counter_agg_idelta_left(summary: CounterSummary) -> f64 {
  function arrow_counter_agg_idelta_right (line 544) | pub fn arrow_counter_agg_idelta_right(
  function counter_agg_idelta_right (line 552) | fn counter_agg_idelta_right(summary: CounterSummary) -> f64 {
  function arrow_counter_agg_with_bounds (line 558) | pub fn arrow_counter_agg_with_bounds(
  function counter_agg_with_bounds (line 568) | fn counter_agg_with_bounds(summary: CounterSummary, bounds: tstzrange) -...
  function arrow_counter_agg_extrapolated_delta (line 591) | pub fn arrow_counter_agg_extrapolated_delta(
  function counter_agg_extrapolated_delta (line 599) | fn counter_agg_extrapolated_delta(summary: CounterSummary, method: &str)...
  function counter_agg_interpolated_delta (line 609) | fn counter_agg_interpolated_delta(
  function arrow_counter_interpolated_delta (line 625) | pub fn arrow_counter_interpolated_delta(
  function arrow_counter_agg_extrapolated_rate (line 651) | pub fn arrow_counter_agg_extrapolated_rate(
  function counter_agg_extrapolated_rate (line 659) | fn counter_agg_extrapolated_rate(summary: CounterSummary, method: &str) ...
  function counter_agg_interpolated_rate (line 669) | fn counter_agg_interpolated_rate(
  function arrow_counter_interpolated_rate (line 685) | pub fn arrow_counter_interpolated_rate(
  function arrow_counter_agg_num_elements (line 711) | pub fn arrow_counter_agg_num_elements(
  function counter_agg_num_elements (line 719) | fn counter_agg_num_elements(summary: CounterSummary) -> i64 {
  function arrow_counter_agg_num_changes (line 725) | pub fn arrow_counter_agg_num_changes(sketch: CounterSummary, _accessor: ...
  function counter_agg_num_changes (line 730) | fn counter_agg_num_changes(summary: CounterSummary) -> i64 {
  function arrow_counter_agg_num_resets (line 736) | pub fn arrow_counter_agg_num_resets(sketch: CounterSummary, _accessor: A...
  function counter_agg_num_resets (line 741) | fn counter_agg_num_resets(summary: CounterSummary) -> i64 {
  function arrow_counter_agg_slope (line 747) | pub fn arrow_counter_agg_slope(sketch: CounterSummary, _accessor: Access...
  function counter_agg_slope (line 752) | fn counter_agg_slope(summary: CounterSummary) -> Option<f64> {
  function arrow_counter_agg_intercept (line 758) | pub fn arrow_counter_agg_intercept(
  function counter_agg_intercept (line 766) | fn counter_agg_intercept(summary: CounterSummary) -> Option<f64> {
  function arrow_counter_agg_corr (line 772) | pub fn arrow_counter_agg_corr(sketch: CounterSummary, _accessor: Accesso...
  function counter_agg_corr (line 777) | fn counter_agg_corr(summary: CounterSummary) -> Option<f64> {
  function arrow_counter_agg_zero_time (line 783) | pub fn arrow_counter_agg_zero_time(
  function counter_agg_counter_zero_time (line 791) | fn counter_agg_counter_zero_time(summary: CounterSummary) -> Option<crat...
  function arrow_counter_agg_first_val (line 797) | pub fn arrow_counter_agg_first_val(sketch: CounterSummary, _accessor: Ac...
  function counter_agg_first_val (line 802) | fn counter_agg_first_val(summary: CounterSummary) -> f64 {
  function arrow_counter_agg_last_val (line 808) | pub fn arrow_counter_agg_last_val(sketch: CounterSummary, _accessor: Acc...
  function counter_agg_last_val (line 813) | fn counter_agg_last_val(summary: CounterSummary) -> f64 {
  function arrow_counter_agg_first_time (line 819) | pub fn arrow_counter_agg_first_time(
  function counter_agg_first_time (line 827) | fn counter_agg_first_time(summary: CounterSummary) -> crate::raw::Timest...
  function arrow_counter_agg_last_time (line 833) | pub fn arrow_counter_agg_last_time(
  function counter_agg_last_time (line 841) | fn counter_agg_last_time(summary: CounterSummary) -> crate::raw::Timesta...
  type Method (line 849) | pub enum Method {
    method as_str (line 854) | pub fn as_str(&self) -> &'static str {
  function method_kind (line 862) | pub fn method_kind(method: &str) -> Method {
  function as_method (line 869) | pub fn as_method(method: &str) -> Option<Method> {
  function assert_close_enough (line 912) | fn assert_close_enough(p1: &MetricSummary, p2: &MetricSummary) {
  function test_counter_aggregate (line 928) | fn test_counter_aggregate() {
  function test_counter_io (line 1046) | fn test_counter_io() {
  function test_counter_byte_io (line 1124) | fn test_counter_byte_io() {
  function delta_after_counter_decrease (line 1195) | fn delta_after_counter_decrease() {
  function delta_after_counter_increase (line 1206) | fn delta_after_counter_increase() {
  function delta_after_counter_decrease_then_increase_to_same_value (line 1215) | fn delta_after_counter_decrease_then_increase_to_same_value() {
  function delta_after_counter_increase_then_decrease_to_same_value (line 1226) | fn delta_after_counter_increase_then_decrease_to_same_value() {
  function idelta_left_after_counter_decrease (line 1237) | fn idelta_left_after_counter_decrease() {
  function idelta_left_after_counter_increase (line 1246) | fn idelta_left_after_counter_increase() {
  function idelta_left_after_counter_increase_then_decrease_to_same_value (line 1255) | fn idelta_left_after_counter_increase_then_decrease_to_same_value() {
  function idelta_left_after_counter_decrease_then_increase_to_same_value (line 1264) | fn idelta_left_after_counter_decrease_then_increase_to_same_value() {
  function idelta_right_after_counter_decrease (line 1274) | fn idelta_right_after_counter_decrease() {
  function idelta_right_after_counter_increase (line 1283) | fn idelta_right_after_counter_increase() {
  function idelta_right_after_counter_increase_then_decrease_to_same_value (line 1292) | fn idelta_right_after_counter_increase_then_decrease_to_same_value() {
  function idelta_right_after_counter_decrease_then_increase_to_same_value (line 1301) | fn idelta_right_after_counter_decrease_then_increase_to_same_value() {
  function counter_agg_interpolation (line 1310) | fn counter_agg_interpolation() {
  function interpolated_delta_with_aligned_point (line 1485) | fn interpolated_delta_with_aligned_point() {
  function irate_left_arrow_match (line 1540) | fn irate_left_arrow_match() {
  function irate_right_arrow_match (line 1559) | fn irate_right_arrow_match() {
  function idelta_left_arrow_match (line 1578) | fn idelta_left_arrow_match() {
  function idelta_right_arrow_match (line 1597) | fn idelta_right_arrow_match() {
  function num_resets_arrow_match (line 1616) | fn num_resets_arrow_match() {
  function first_and_last_val (line 1635) | fn first_and_last_val() {
  function first_and_last_val_arrow_match (line 1664) | fn first_and_last_val_arrow_match() {
  function first_and_last_time (line 1695) | fn first_and_last_time() {
  function first_and_last_time_arrow_match (line 1725) | fn first_and_last_time_arrow_match() {
  function decrease (line 1766) | pub fn decrease(client: &mut pgrx::spi::SpiClient) {
  function increase (line 1786) | pub fn increase(client: &mut pgrx::spi::SpiClient) {
  function decrease_then_increase_to_same_value (line 1806) | pub fn decrease_then_increase_to_same_value(client: &mut pgrx::spi::SpiC...
  function increase_then_decrease_to_same_value (line 1827) | pub fn increase_then_decrease_to_same_value(client: &mut pgrx::spi::SpiC...
  function make_test_table (line 1848) | pub fn make_test_table(client: &mut pgrx::spi::SpiClient, name: &str) {

FILE: extension/src/counter_agg/accessors.rs
  function counter_interpolated_rate_accessor (line 24) | fn counter_interpolated_rate_accessor(
  function counter_interpolated_delta_accessor (line 65) | fn counter_interpolated_delta_accessor(

FILE: extension/src/countminsketch.rs
  function new (line 28) | fn new(width: u32, depth: u32, counters: Vec<i64>) -> Self {
  function to_internal_countminsketch (line 39) | pub fn to_internal_countminsketch(&self) -> CountMinSketchInternal {
  function from_internal_countminsketch (line 64) | pub fn from_internal_countminsketch(sketch: &mut CountMinSketchInternal)...
  type State (line 80) | type State = CountMinSketchInternal;
  function transition (line 82) | fn transition(
  function finally (line 102) | fn finally(state: Option<&mut State>) -> Option<CountMinSketch<'static>> {
  constant PARALLEL_SAFE (line 106) | const PARALLEL_SAFE: bool = true;
  function serialize (line 108) | fn serialize(state: &mut State) -> bytea {
  function deserialize (line 112) | fn deserialize(bytes: bytea) -> State {
  function combine (line 116) | fn combine(state1: Option<&State>, state2: Option<&State>) -> Option<Sta...
  function approx_count (line 130) | pub fn approx_count<'a>(item: String, aggregate: Option<CountMinSketch<'...
  function test_countminsketch (line 141) | fn test_countminsketch() {
  function test_countminsketch_combine (line 205) | fn test_countminsketch_combine() {
  function countminsketch_io_test (line 233) | fn countminsketch_io_test() {
  function test_cms_null_input_yields_null_output (line 267) | fn test_cms_null_input_yields_null_output() {
  function test_approx_count_null_input_yields_null_output (line 284) | fn test_approx_count_null_input_yields_null_output() {

FILE: extension/src/datum_utils.rs
  function deep_copy_datum (line 19) | pub(crate) unsafe fn deep_copy_datum(datum: Datum, typoid: Oid) -> Datum {
  function free_datum (line 35) | pub(crate) unsafe fn free_datum(datum: Datum, typoid: Oid) {
  function ts_interval_sum_to_ms (line 44) | pub fn ts_interval_sum_to_ms(
  function interval_to_ms (line 63) | pub fn interval_to_ms(ref_time: &crate::raw::TimestampTz, interval: &cra...
  type TextSerializableDatumWriter (line 67) | pub struct TextSerializableDatumWriter {
    method from_oid (line 72) | pub fn from_oid(typoid: Oid) -> Self {
    method make_serializable (line 85) | pub fn make_serializable(&mut self, datum: Datum) -> TextSerializeable...
  type DatumFromSerializedTextReader (line 90) | pub struct DatumFromSerializedTextReader {
    method from_oid (line 96) | pub fn from_oid(typoid: Oid) -> Self {
    method read_datum (line 111) | pub fn read_datum(&mut self, datum_str: &str) -> Datum {
  type TextSerializeableDatum (line 118) | pub struct TextSerializeableDatum(Datum, *mut pg_sys::FmgrInfo);
  method serialize (line 121) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type DatumHashBuilder (line 131) | pub(crate) struct DatumHashBuilder {
    method from_type_id (line 138) | pub(crate) unsafe fn from_type_id(type_id: pg_sys::Oid, collation: Opt...
    method from_type_cache_entry (line 144) | pub(crate) unsafe fn from_type_cache_entry(
    method deserialize (line 258) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method clone (line 180) | fn clone(&self) -> Self {
  type Hasher (line 186) | type Hasher = DatumHashBuilder;
  method build_hasher (line 188) | fn build_hasher(&self) -> Self::Hasher {
  method finish (line 198) | fn finish(&self) -> u64 {
  method write (line 214) | fn write(&mut self, bytes: &[u8]) {
  method write_usize (line 224) | fn write_usize(&mut self, i: usize) {
  method eq (line 236) | fn eq(&self, other: &Self) -> bool {
  method serialize (line 244) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function div_round_up (line 271) | fn div_round_up(numerator: usize, divisor: usize) -> usize {
  function round_to_multiple (line 276) | fn round_to_multiple(value: usize, multiple: usize) -> usize {
  function padded_va_len (line 281) | fn padded_va_len(ptr: *const pg_sys::varlena) -> usize {
  method serialize (line 300) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function deserialize (line 316) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function from (line 352) | fn from(input: (Oid, Vec<Datum>)) -> Self {
  type DatumStoreIterator (line 443) | pub enum DatumStoreIterator<'a, 'b> {
  type Item (line 459) | type Item = Datum;
  method next (line 461) | fn next(&mut self) -> Option<Self::Item> {
  function iter (line 495) | pub fn iter<'b>(&'b self) -> DatumStoreIterator<'a, 'b> {
  function into_anyelement_iter (line 529) | pub fn into_anyelement_iter(self) -> impl Iterator<Item = AnyElement> + ...
  type DatumStoreIntoIterator (line 538) | pub enum DatumStoreIntoIterator<'a> {
  type Item (line 557) | type Item = Datum;
  method next (line 559) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 609) | type Item = Datum;
  type IntoIter (line 610) | type IntoIter = DatumStoreIntoIterator<'a>;
  method into_iter (line 612) | fn into_iter(self) -> Self::IntoIter {
  type State (line 664) | type State = (Oid, Vec<Datum>);
  function transition (line 666) | fn transition(
  function finally (line 682) | fn finally(state: Option<&mut State>) -> Option<DatumStoreTester<'static...
  function test_value_datum_store (line 695) | fn test_value_datum_store() {
  function test_varlena_datum_store (line 706) | fn test_varlena_datum_store() {
  function test_byref_datum_store (line 717) | fn test_byref_datum_store() {

FILE: extension/src/duration.rs
  type DurationUnit (line 9) | pub enum DurationUnit {
    method microseconds (line 19) | pub fn microseconds(self) -> u32 {
    method convert_unit (line 30) | pub fn convert_unit(self, amount: f64, to: Self) -> f64 {
    method from_str (line 36) | pub fn from_str(s: &str) -> Option<Self> {
    method fmt (line 52) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function convert_unit (line 68) | fn convert_unit() {
  function parse_unit (line 76) | fn parse_unit() {

FILE: extension/src/frequency.rs
  constant DEFAULT_ZETA_SKEW (line 42) | const DEFAULT_ZETA_SKEW: f64 = 1.1;
  function zeta_eq_n (line 45) | fn zeta_eq_n(skew: f64, n: u64) -> f64 {
  function zeta_le_n (line 49) | fn zeta_le_n(skew: f64, n: u64) -> f64 {
  type SpaceSavingEntry (line 53) | struct SpaceSavingEntry {
    method clone (line 60) | fn clone(&self, typoid: Oid) -> SpaceSavingEntry {
  type SpaceSavingTransState (line 69) | pub struct SpaceSavingTransState {
    method deserialize (line 138) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method max_size_for_freq (line 194) | fn max_size_for_freq(min_freq: f64) -> u32 {
    method freq_agg_from_type_id (line 198) | fn freq_agg_from_type_id(min_freq: f64, typ: pg_sys::Oid, collation: O...
    method mcv_agg_from_type_id (line 209) | fn mcv_agg_from_type_id(
    method ingest_aggregate_data (line 236) | fn ingest_aggregate_data(
    method ingest_aggregate_ints (line 257) | fn ingest_aggregate_ints(
    method type_oid (line 279) | fn type_oid(&self) -> Oid {
    method add (line 283) | fn add(&mut self, element: PgAnyElement) {
    method move_left (line 319) | fn move_left(&mut self, i: usize) {
    method update_map_index (line 334) | fn update_map_index(&mut self, i: usize) {
    method update_all_map_indices (line 343) | fn update_all_map_indices(&mut self) {
    method combine (line 349) | fn combine(one: &SpaceSavingTransState, two: &SpaceSavingTransState) -...
    method from (line 459) | fn from(data_in: (&SpaceSavingAggregate<'input>, &pg_sys::FunctionCall...
    method from (line 535) | fn from(
    method from (line 609) | fn from(data_in: (&SpaceSavingTextAggregate<'input>, &pg_sys::Function...
  method clone (line 79) | fn clone(&self) -> Self {
  method serialize (line 112) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function from (line 430) | fn from(trans: &SpaceSavingTransState) -> Self {
  function from (line 502) | fn from(trans: &SpaceSavingTransState) -> Self {
  function from (line 579) | fn from(trans: &SpaceSavingTransState) -> Self {
  function mcv_agg_trans (line 635) | pub fn mcv_agg_trans(
  function mcv_agg_bigint_trans (line 645) | pub fn mcv_agg_bigint_trans(
  function mcv_agg_text_trans (line 655) | pub fn mcv_agg_text_trans(
  function mcv_agg_with_skew_trans (line 665) | pub fn mcv_agg_with_skew_trans(
  function mcv_agg_with_skew_bigint_trans (line 684) | pub fn mcv_agg_with_skew_bigint_trans(
  function mcv_agg_with_skew_text_trans (line 710) | pub fn mcv_agg_with_skew_text_trans(
  function freq_agg_trans (line 737) | pub fn freq_agg_trans(
  function freq_agg_bigint_trans (line 757) | pub fn freq_agg_bigint_trans(
  function freq_agg_text_trans (line 773) | pub fn freq_agg_text_trans(
  function space_saving_trans (line 789) | pub fn space_saving_trans<F>(
  function rollup_agg_trans (line 820) | pub fn rollup_agg_trans<'input>(
  function rollup_agg_trans_inner (line 832) | pub fn rollup_agg_trans_inner(
  function rollup_agg_bigint_trans (line 850) | pub fn rollup_agg_bigint_trans<'input>(
  function rollup_agg_bigint_trans_inner (line 862) | pub fn rollup_agg_bigint_trans_inner(
  function rollup_agg_text_trans (line 880) | pub fn rollup_agg_text_trans<'input>(
  function rollup_agg_text_trans_inner (line 892) | pub fn rollup_agg_text_trans_inner(
  function space_saving_combine (line 910) | pub fn space_saving_combine(
  function space_saving_combine_inner (line 917) | pub fn space_saving_combine_inner(
  function space_saving_final (line 933) | fn space_saving_final(
  function space_saving_bigint_final (line 942) | fn space_saving_bigint_final(
  function space_saving_text_final (line 951) | fn space_saving_text_final(
  function space_saving_serialize (line 960) | fn space_saving_serialize(state: Internal) -> bytea {
  function space_saving_deserialize (line 966) | pub fn space_saving_deserialize(bytes: bytea, _internal: Internal) -> Op...
  function freq_iter (line 1260) | pub fn freq_iter<'a>(
  function freq_bigint_iter (line 1291) | pub fn freq_bigint_iter<'a>(
  function arrow_freq_bigint_iter (line 1314) | pub fn arrow_freq_bigint_iter<'a>(
  function freq_text_iter (line 1329) | pub fn freq_text_iter<'a>(
  function arrow_freq_text_iter (line 1353) | pub fn arrow_freq_text_iter<'a>(
  function validate_topn_for_mcv_agg (line 1367) | fn validate_topn_for_mcv_agg(
  function topn (line 1397) | pub fn topn(
  function default_topn (line 1433) | pub fn default_topn(
  function topn_bigint (line 1445) | pub fn topn_bigint(agg: SpaceSavingBigIntAggregate<'_>, n: i32) -> SetOf...
  function arrow_topn_bigint (line 1466) | pub fn arrow_topn_bigint<'a>(
  function default_topn_bigint (line 1474) | pub fn default_topn_bigint(agg: SpaceSavingBigIntAggregate<'_>) -> SetOf...
  function arrow_default_topn_bigint (line 1484) | pub fn arrow_default_topn_bigint<'a>(
  function topn_text (line 1492) | pub fn topn_text(agg: SpaceSavingTextAggregate<'_>, n: i32) -> SetOfIter...
  function arrow_topn_text (line 1516) | pub fn arrow_topn_text<'a>(
  function default_topn_text (line 1524) | pub fn default_topn_text(agg: SpaceSavingTextAggregate<'_>) -> SetOfIter...
  function arrow_default_topn_text (line 1534) | pub fn arrow_default_topn_text<'a>(
  function max_frequency (line 1542) | pub fn max_frequency(agg: SpaceSavingAggregate<'_>, value: AnyElement) -...
  function min_frequency (line 1555) | pub fn min_frequency(agg: SpaceSavingAggregate<'_>, value: AnyElement) -...
  function max_bigint_frequency (line 1570) | pub fn max_bigint_frequency(agg: SpaceSavingBigIntAggregate<'_>, value: ...
  function arrow_max_bigint_frequency (line 1579) | pub fn arrow_max_bigint_frequency<'a>(
  function min_bigint_frequency (line 1587) | pub fn min_bigint_frequency(agg: SpaceSavingBigIntAggregate<'_>, value: ...
  function arrow_min_bigint_frequency (line 1598) | pub fn arrow_min_bigint_frequency<'a>(
  function max_text_frequency (line 1607) | pub fn max_text_frequency(agg: SpaceSavingTextAggregate<'_>, value: text...
  function min_text_frequency (line 1621) | pub fn min_text_frequency(agg: SpaceSavingTextAggregate<'_>, value: text...
  type TopNIterator (line 1635) | struct TopNIterator<Input, InputIterator: std::iter::Iterator<Item = Inp...
  function new (line 1645) | fn new(
  type Item (line 1666) | type Item = Input;
  method next (line 1667) | fn next(&mut self) -> Option<Self::Item> {
  function varlena_to_string (line 1682) | unsafe fn varlena_to_string(vl: *const pg_sys::varlena) -> String {
  function test_freq_aggregate (line 1700) | fn test_freq_aggregate() {
  function test_topn_aggregate (line 1746) | fn test_topn_aggregate() {
  function explicit_aggregate_test (line 1794) | fn explicit_aggregate_test() {
  function setup_with_test_table (line 2007) | fn setup_with_test_table(client: &mut pgrx::spi::SpiClient) {
  function test_topn (line 2054) | fn test_topn() {
  function topn_on_underskewed_mcv_agg (line 2123) | fn topn_on_underskewed_mcv_agg() {
  function topn_high_n_on_mcv_agg (line 2138) | fn topn_high_n_on_mcv_agg() {
  function topn_requires_n_for_freq_agg (line 2153) | fn topn_requires_n_for_freq_agg() {
  function test_into_values (line 2171) | fn test_into_values() {
  function test_frequency_getters (line 2234) | fn test_frequency_getters() {
  function test_rollups (line 2285) | fn test_rollups() {
  function test_freq_agg_invariant (line 2358) | fn test_freq_agg_invariant() {
  function test_freq_agg_rollup_maintains_invariant (line 2393) | fn test_freq_agg_rollup_maintains_invariant() {
  function test_mcv_agg_invariant (line 2442) | fn test_mcv_agg_invariant() {

FILE: extension/src/gauge_agg.rs
  type FlatSummary (line 29) | pub struct FlatSummary {
  method interpolate (line 54) | pub(super) fn interpolate(
  type GaugeSummaryTransState (line 118) | struct GaugeSummaryTransState {
    method new (line 130) | fn new() -> Self {
    method push_point (line 138) | fn push_point(&mut self, value: TSPoint) {
    method combine_points (line 142) | fn combine_points(&mut self) {
    method push_summary (line 163) | fn push_summary(&mut self, other: &Self) {
    method combine_summaries (line 170) | fn combine_summaries(&mut self) {
  function gauge_summary_trans_serialize (line 190) | fn gauge_summary_trans_serialize(state: Internal) -> bytea {
  function gauge_summary_trans_deserialize (line 198) | fn gauge_summary_trans_deserialize(bytes: bytea, _internal: Internal) ->...
  function gauge_summary_trans_deserialize_inner (line 201) | fn gauge_summary_trans_deserialize_inner(bytes: bytea) -> Inner<GaugeSum...
  function gauge_agg_trans (line 207) | fn gauge_agg_trans(
  function gauge_agg_trans_inner (line 216) | fn gauge_agg_trans_inner(
  function gauge_agg_trans_no_bounds (line 249) | fn gauge_agg_trans_no_bounds(
  function gauge_agg_summary_trans (line 259) | fn gauge_agg_summary_trans(
  function gauge_agg_summary_trans_inner (line 266) | fn gauge_agg_summary_trans_inner(
  function gauge_agg_combine (line 288) | fn gauge_agg_combine(
  function gauge_agg_combine_inner (line 295) | fn gauge_agg_combine_inner(
  function gauge_agg_final (line 328) | fn gauge_agg_final(state: Internal, fcinfo: pg_sys::FunctionCallInfo) ->...
  function gauge_agg_final_inner (line 331) | fn gauge_agg_final_inner(
  function arrow_delta (line 430) | fn arrow_delta(sketch: GaugeSummary, _accessor: AccessorDelta) -> f64 {
  function delta (line 435) | fn delta(summary: GaugeSummary) -> f64 {
  function arrow_gauge_agg_rate (line 441) | fn arrow_gauge_agg_rate(sketch: GaugeSummary, _accessor: AccessorRate) -...
  function rate (line 446) | fn rate(summary: GaugeSummary) -> Option<f64> {
  function arrow_time_delta (line 452) | fn arrow_time_delta(sketch: GaugeSummary, _accessor: AccessorTimeDelta) ...
  function time_delta (line 457) | fn time_delta(summary: GaugeSummary) -> f64 {
  function arrow_irate_left (line 463) | fn arrow_irate_left(sketch: GaugeSummary, _accessor: AccessorIrateLeft) ...
  function irate_left (line 468) | fn irate_left(summary: GaugeSummary) -> Option<f64> {
  function arrow_irate_right (line 474) | fn arrow_irate_right(sketch: GaugeSummary, _accessor: AccessorIrateRight...
  function irate_right (line 479) | fn irate_right(summary: GaugeSummary) -> Option<f64> {
  function arrow_idelta_left (line 485) | fn arrow_idelta_left(sketch: GaugeSummary, _accessor: AccessorIdeltaLeft...
  function idelta_left (line 490) | fn idelta_left(summary: GaugeSummary) -> f64 {
  function arrow_idelta_right (line 496) | fn arrow_idelta_right(sketch: GaugeSummary, _accessor: AccessorIdeltaRig...
  function idelta_right (line 501) | fn idelta_right(summary: GaugeSummary) -> f64 {
  function arrow_with_bounds (line 507) | fn arrow_with_bounds(sketch: GaugeSummary, accessor: AccessorWithBounds)...
  function with_bounds (line 514) | fn with_bounds(summary: GaugeSummary, bounds: tstzrange) -> GaugeSummary {
  function arrow_extrapolated_delta (line 526) | fn arrow_extrapolated_delta(
  function extrapolated_delta (line 534) | fn extrapolated_delta(summary: GaugeSummary) -> Option<f64> {
  function interpolated_delta (line 539) | fn interpolated_delta(
  function arrow_extrapolated_rate (line 552) | fn arrow_extrapolated_rate(
  function extrapolated_rate (line 560) | fn extrapolated_rate(summary: GaugeSummary) -> Option<f64> {
  function interpolated_rate (line 565) | fn interpolated_rate(
  function arrow_num_elements (line 578) | fn arrow_num_elements(sketch: GaugeSummary, _accessor: AccessorNumElemen...
  function num_elements (line 583) | fn num_elements(summary: GaugeSummary) -> i64 {
  function arrow_num_changes (line 589) | fn arrow_num_changes(sketch: GaugeSummary, _accessor: AccessorNumChanges...
  function num_changes (line 594) | fn num_changes(summary: GaugeSummary) -> i64 {
  function arrow_slope (line 600) | fn arrow_slope(sketch: GaugeSummary, _accessor: AccessorSlope) -> Option...
  function slope (line 605) | fn slope(summary: GaugeSummary) -> Option<f64> {
  function arrow_intercept (line 611) | fn arrow_intercept(sketch: GaugeSummary, _accessor: AccessorIntercept) -...
  function intercept (line 616) | fn intercept(summary: GaugeSummary) -> Option<f64> {
  function arrow_corr (line 622) | fn arrow_corr(sketch: GaugeSummary, _accessor: AccessorCorr) -> Option<f...
  function corr (line 627) | fn corr(summary: GaugeSummary) -> Option<f64> {
  function arrow_zero_time (line 633) | fn arrow_zero_time(
  function gauge_zero_time (line 641) | fn gauge_zero_time(summary: GaugeSummary) -> Option<crate::raw::Timestam...
  method from (line 646) | fn from(pg: GaugeSummary) -> Self {
  method from (line 662) | fn from(internal: MetricSummary) -> Self {
  function round_trip (line 703) | fn round_trip() {
  function delta_after_gauge_decrease (line 779) | fn delta_after_gauge_decrease() {
  function delta_after_gauge_increase (line 788) | fn delta_after_gauge_increase() {
  function delta_after_gauge_decrease_then_increase_to_same_value (line 797) | fn delta_after_gauge_decrease_then_increase_to_same_value() {
  function delta_after_gauge_increase_then_decrease_to_same_value (line 806) | fn delta_after_gauge_increase_then_decrease_to_same_value() {
  function idelta_left_after_gauge_decrease (line 815) | fn idelta_left_after_gauge_decrease() {
  function idelta_left_after_gauge_increase (line 824) | fn idelta_left_after_gauge_increase() {
  function idelta_left_after_gauge_increase_then_decrease_to_same_value (line 833) | fn idelta_left_after_gauge_increase_then_decrease_to_same_value() {
  function idelta_left_after_gauge_decrease_then_increase_to_same_value (line 842) | fn idelta_left_after_gauge_decrease_then_increase_to_same_value() {
  function idelta_right_after_gauge_decrease (line 851) | fn idelta_right_after_gauge_decrease() {
  function idelta_right_after_gauge_increase (line 860) | fn idelta_right_after_gauge_increase() {
  function idelta_right_after_gauge_increase_then_decrease_to_same_value (line 869) | fn idelta_right_after_gauge_increase_then_decrease_to_same_value() {
  function idelta_right_after_gauge_decrease_then_increase_to_same_value (line 878) | fn idelta_right_after_gauge_decrease_then_increase_to_same_value() {
  function assert_close_enough (line 888) | fn assert_close_enough(p1: &MetricSummary, p2: &MetricSummary) {
  function rollup (line 905) | fn rollup() {
  function gauge_agg_interpolation (line 952) | fn gauge_agg_interpolation() {
  function guage_agg_interpolated_delta_with_aligned_point (line 1042) | fn guage_agg_interpolated_delta_with_aligned_point() {
  function no_results_on_null_input (line 1091) | fn no_results_on_null_input() {

FILE: extension/src/heartbeat_agg.rs
  constant BUFFER_SIZE (line 27) | const BUFFER_SIZE: usize = 1000;
  type HeartbeatTransState (line 31) | pub struct HeartbeatTransState {
    method new (line 41) | pub fn new(start: i64, end: i64, interval: i64) -> Self {
    method insert (line 53) | pub fn insert(&mut self, time: i64) {
    method process_batch (line 61) | pub fn process_batch(&mut self) {
    method extend_covered_interval (line 96) | fn extend_covered_interval(&mut self, new_start: i64, new_end: i64) {
    method combine_intervals (line 110) | fn combine_intervals(&mut self, new_intervals: Vec<(i64, i64)>) {
    method combine (line 167) | pub fn combine(&mut self, mut other: HeartbeatTransState) {
    method get_buffer (line 184) | pub fn get_buffer(&self) -> &Vec<i64> {
    method get_liveness (line 187) | pub fn get_liveness(&self) -> &Vec<(i64, i64)> {
    method from (line 581) | fn from(agg: HeartbeatAgg<'static>) -> Self {
  function trim_to (line 209) | fn trim_to(self, start: Option<i64>, end: Option<i64>) -> HeartbeatAgg<'...
  function sum_live_intervals (line 271) | fn sum_live_intervals(self) -> i64 {
  function interpolate_start (line 281) | fn interpolate_start(&mut self, pred: &Self) {
  function live_ranges (line 325) | pub fn live_ranges(
  function arrow_heartbeat_agg_live_ranges (line 340) | pub fn arrow_heartbeat_agg_live_ranges(
  function dead_ranges (line 348) | pub fn dead_ranges(
  function arrow_heartbeat_agg_dead_ranges (line 386) | pub fn arrow_heartbeat_agg_dead_ranges(
  function uptime (line 394) | pub fn uptime(agg: HeartbeatAgg<'static>) -> Interval {
  function arrow_heartbeat_agg_uptime (line 400) | pub fn arrow_heartbeat_agg_uptime(
  function interpolated_uptime (line 408) | pub fn interpolated_uptime(
  function arrow_heartbeat_agg_interpolated_uptime (line 417) | pub fn arrow_heartbeat_agg_interpolated_uptime(
  function downtime (line 425) | pub fn downtime(agg: HeartbeatAgg<'static>) -> Interval {
  function arrow_heartbeat_agg_downtime (line 431) | pub fn arrow_heartbeat_agg_downtime(
  function interpolated_downtime (line 439) | pub fn interpolated_downtime(
  function arrow_heartbeat_agg_interpolated_downtime (line 448) | pub fn arrow_heartbeat_agg_interpolated_downtime(
  function live_at (line 456) | pub fn live_at(agg: HeartbeatAgg<'static>, test: TimestampTz) -> bool {
  function arrow_heartbeat_agg_live_at (line 485) | pub fn arrow_heartbeat_agg_live_at(
  function interpolate_heartbeat_agg (line 494) | fn interpolate_heartbeat_agg(
  function arrow_heartbeat_agg_interpolate (line 507) | pub fn arrow_heartbeat_agg_interpolate(
  function num_live_ranges (line 515) | pub fn num_live_ranges(agg: HeartbeatAgg<'static>) -> i64 {
  function arrow_heartbeat_agg_num_live_ranges (line 521) | pub fn arrow_heartbeat_agg_num_live_ranges(
  function num_gaps (line 529) | pub fn num_gaps(agg: HeartbeatAgg<'static>) -> i64 {
  function arrow_heartbeat_agg_num_gaps (line 545) | pub fn arrow_heartbeat_agg_num_gaps(agg: HeartbeatAgg<'static>, _accesso...
  function trim_to (line 550) | pub fn trim_to(
  function arrow_heartbeat_agg_trim_to (line 568) | pub fn arrow_heartbeat_agg_trim_to(
  function heartbeat_trans (line 598) | pub fn heartbeat_trans(
  function heartbeat_trans_inner (line 616) | pub fn heartbeat_trans_inner(
  function heartbeat_final (line 639) | pub fn heartbeat_final(
  function heartbeat_final_inner (line 645) | pub fn heartbeat_final_inner(
  function heartbeat_rollup_trans (line 678) | pub fn heartbeat_rollup_trans(
  function heartbeat_rollup_trans_inner (line 685) | pub fn heartbeat_rollup_trans_inner(
  function test_heartbeat_trans_state (line 739) | pub fn test_heartbeat_trans_state() {
  function test_heartbeat_agg (line 794) | pub fn test_heartbeat_agg() {
  function test_heartbeat_rollup (line 1076) | pub fn test_heartbeat_rollup() {
  function test_heartbeat_combining_rollup (line 1126) | pub fn test_heartbeat_combining_rollup() {
  function test_heartbeat_trim_to (line 1226) | pub fn test_heartbeat_trim_to() {
  function test_heartbeat_agg_interpolation (line 1303) | pub fn test_heartbeat_agg_interpolation() {
  function test_heartbeat_agg_text_io (line 1690) | fn test_heartbeat_agg_text_io() {
  function test_heartbeat_agg_byte_io (line 1741) | fn test_heartbeat_agg_byte_io() {
  function test_rollup_overlap (line 1810) | fn test_rollup_overlap() {

FILE: extension/src/heartbeat_agg/accessors.rs
  function empty_agg (line 9) | fn empty_agg<'a>() -> HeartbeatAgg<'a> {
  function heartbeat_agg_interpolated_uptime_accessor (line 33) | fn heartbeat_agg_interpolated_uptime_accessor<'a>(
  function pred (line 48) | pub fn pred(&self) -> Option<HeartbeatAgg<'a>> {
  function heartbeat_agg_interpolated_downtime_accessor (line 67) | fn heartbeat_agg_interpolated_downtime_accessor<'a>(
  function pred (line 82) | pub fn pred(&self) -> Option<HeartbeatAgg<'a>> {
  function heartbeat_agg_interpolate_accessor (line 101) | fn heartbeat_agg_interpolate_accessor<'a>(
  function pred (line 116) | pub fn pred(&self) -> Option<HeartbeatAgg<'a>> {
  function heartbeat_agg_trim_to_accessor (line 138) | fn heartbeat_agg_trim_to_accessor(

FILE: extension/src/hyperloglog.rs
  type HashableDatum (line 27) | struct HashableDatum(Datum);
  method hash (line 31) | fn hash<H: Hasher>(&self, state: &mut H) {
  type HyperLogLogTrans (line 37) | pub struct HyperLogLogTrans {
  function hyperloglog_trans (line 44) | pub fn hyperloglog_trans(
  constant APPROX_COUNT_DISTINCT_DEFAULT_SIZE (line 58) | const APPROX_COUNT_DISTINCT_DEFAULT_SIZE: i32 = 32768;
  function approx_count_distinct_trans (line 62) | pub fn approx_count_distinct_trans(
  function hyperloglog_trans_inner (line 79) | pub fn hyperloglog_trans_inner(
  function hyperloglog_combine (line 126) | pub fn hyperloglog_combine(
  function hyperloglog_combine_inner (line 133) | pub fn hyperloglog_combine_inner(
  function hyperloglog_serialize (line 155) | pub fn hyperloglog_serialize(state: Internal) -> bytea {
  function hyperloglog_deserialize (line 163) | pub fn hyperloglog_deserialize(bytes: bytea, _internal: Internal) -> Opt...
  function hyperloglog_deserialize_inner (line 166) | pub fn hyperloglog_deserialize_inner(bytes: bytea) -> Inner<HyperLogLogT...
  function hyperloglog_final (line 209) | fn hyperloglog_final(
  function hyperloglog_final_inner (line 215) | fn hyperloglog_final_inner(
  function hyperloglog_union (line 278) | pub fn hyperloglog_union<'a>(
  function hyperloglog_union_inner (line 285) | pub fn hyperloglog_union_inner(
  function arrow_hyperloglog_count (line 343) | pub fn arrow_hyperloglog_count<'a>(
  function hyperloglog_count (line 351) | pub fn hyperloglog_count<'a>(hyperloglog: HyperLogLog<'a>) -> i64 {
  function arrow_hyperloglog_error (line 376) | pub fn arrow_hyperloglog_error<'a>(sketch: HyperLogLog<'a>, _accessor: A...
  function hyperloglog_error (line 381) | pub fn hyperloglog_error<'a>(hyperloglog: HyperLogLog<'a>) -> f64 {
  function build_from (line 390) | pub fn build_from(
  function flatten_log (line 414) | fn flatten_log(hyperloglog: &mut HLL<HashableDatum, DatumHashBuilder>) -...
  function unflatten_log (line 451) | fn unflatten_log(hyperloglog: HyperLogLog) -> HLL<HashableDatum, DatumHa...
  function test_hll_aggregate (line 488) | fn test_hll_aggregate() {
  function test_approx_count_distinct_aggregate (line 547) | fn test_approx_count_distinct_aggregate() {
  function test_hll_byte_io (line 623) | fn test_hll_byte_io() {
  function test_hll_aggregate_int (line 703) | fn test_hll_aggregate_int() {
  function test_hll_aggregate_text (line 757) | fn test_hll_aggregate_text() {
  function test_hll_union_text (line 819) | fn test_hll_union_text() {
  function test_hll_null_input_yields_null_output (line 881) | fn test_hll_null_input_yields_null_output() {
  function test_hll_error_too_small (line 896) | fn test_hll_error_too_small() {
  function test_hll_size_min (line 909) | fn test_hll_size_min() {
  function test_hll_size_max (line 922) | fn test_hll_size_max() {
  function stderror_arrow_match (line 935) | fn stderror_arrow_match() {
  function bias_correct_values_accurate (line 958) | fn bias_correct_values_accurate() {
  function test_hll_error_too_large (line 994) | fn test_hll_error_too_large() {
  function test_hll_null_rollup (line 1007) | fn test_hll_null_rollup() {

FILE: extension/src/lib.rs
  function _PG_init (line 62) | pub extern "C-unwind" fn _PG_init() {
  function setup (line 74) | pub fn setup(_options: Vec<&str>) {
  function postgresql_conf_options (line 78) | pub fn postgresql_conf_options() -> Vec<&'static str> {

FILE: extension/src/lttb.rs
  type LttbTrans (line 15) | pub struct LttbTrans {
  function lttb_trans (line 22) | pub fn lttb_trans(
  function lttb_trans_inner (line 31) | pub fn lttb_trans_inner(
  function lttb_final (line 69) | pub fn lttb_final(
  function lttb_final_inner (line 75) | pub fn lttb_final_inner(
  function gp_lttb_trans (line 100) | pub fn gp_lttb_trans(
  function gp_lttb_final (line 130) | pub fn gp_lttb_final(
  function gap_preserving_lttb_final_inner (line 136) | pub fn gap_preserving_lttb_final_inner(
  function lttb (line 259) | pub fn lttb(data: &[TSPoint], threshold: usize) -> Cow<'_, [TSPoint]> {
  function lttb_on_timevector (line 334) | pub fn lttb_on_timevector(
  function lttb_ts (line 342) | pub fn lttb_ts(data: Timevector_TSTZ_F64, threshold: usize) -> Timevecto...
  function test_lttb_equivalence (line 438) | fn test_lttb_equivalence() {
  function test_lttb_result (line 501) | fn test_lttb_result() {
  function test_gp_lttb (line 550) | fn test_gp_lttb() {
  function test_gp_lttb_with_gap (line 607) | fn test_gp_lttb_with_gap() {

FILE: extension/src/nmost.rs
  type NMostTransState (line 28) | pub struct NMostTransState<T: Ord> {
  function new (line 34) | fn new(capacity: usize, first_val: T) -> NMostTransState<T> {
  function new_entry (line 45) | fn new_entry(&mut self, new_val: T) {
  function belongs_in_heap (line 58) | fn belongs_in_heap(&self, val: &T) -> bool {
  function from (line 65) | fn from(input: (&[T], usize)) -> Self {
  function nmost_trans_function (line 75) | fn nmost_trans_function<T: Ord>(
  function nmost_rollup_trans_function (line 94) | fn nmost_rollup_trans_function<T: Ord + Copy>(
  function nmost_trans_combine (line 119) | fn nmost_trans_combine<T: Clone + Ord + Copy>(
  type NMostByTransState (line 144) | pub struct NMostByTransState<T: Ord> {
  function new (line 151) | fn new(capacity: usize, first_val: T, first_element: pgrx::AnyElement) -...
  function new_entry (line 161) | fn new_entry(&mut self, new_val: T, new_element: pgrx::AnyElement) {
  function into_sorted_parts (line 189) | fn into_sorted_parts(self) -> (usize, Vec<T>, DatumStore<'static>) {
  function from (line 208) | fn from(in_tuple: (&[T], &DatumStore, usize)) -> Self {
  function nmost_by_trans_function (line 219) | fn nmost_by_trans_function<T: Ord + Clone>(
  function nmost_by_rollup_trans_function (line 239) | fn nmost_by_rollup_trans_function<T: Ord + Copy>(

FILE: extension/src/nmost/max_by_float.rs
  type MaxByFloatTransType (line 15) | type MaxByFloatTransType = NMostByTransState<Reverse<NotNan<f64>>>;
  function from (line 27) | fn from(item: MaxByFloatTransType) -> Self {
  function max_n_by_float_trans (line 48) | pub fn max_n_by_float_trans(
  function max_n_by_float_rollup_trans (line 66) | pub fn max_n_by_float_rollup_trans(
  function max_n_by_float_final (line 89) | pub fn max_n_by_float_final(state: Internal) -> MaxByFloats<'static> {
  function max_n_by_float_to_values (line 94) | pub fn max_n_by_float_to_values(
  function max_by_float_correctness (line 142) | fn max_by_float_correctness() {

FILE: extension/src/nmost/max_by_int.rs
  type MaxByIntTransType (line 14) | type MaxByIntTransType = NMostByTransState<Reverse<i64>>;
  function from (line 26) | fn from(item: MaxByIntTransType) -> Self {
  function max_n_by_int_trans (line 47) | pub fn max_n_by_int_trans(
  function max_n_by_int_rollup_trans (line 65) | pub fn max_n_by_int_rollup_trans(
  function max_n_by_int_final (line 88) | pub fn max_n_by_int_final(state: Internal) -> MaxByInts<'static> {
  function max_n_by_int_to_values (line 93) | pub fn max_n_by_int_to_values(
  function max_by_int_correctness (line 141) | fn max_by_int_correctness() {

FILE: extension/src/nmost/max_by_time.rs
  type MaxByTimeTransType (line 14) | type MaxByTimeTransType = NMostByTransState<Reverse<pg_sys::TimestampTz>>;
  function from (line 26) | fn from(item: MaxByTimeTransType) -> Self {
  function max_n_by_time_trans (line 47) | pub fn max_n_by_time_trans(
  function max_n_by_time_rollup_trans (line 65) | pub fn max_n_by_time_rollup_trans(
  function max_n_by_time_final (line 88) | pub fn max_n_by_time_final(state: Internal) -> MaxByTimes<'static> {
  function max_n_by_time_to_values (line 93) | pub fn max_n_by_time_to_values(
  function max_by_time_correctness (line 148) | fn max_by_time_correctness() {

FILE: extension/src/nmost/max_float.rs
  type MaxFloatTransType (line 17) | type MaxFloatTransType = NMostTransState<Reverse<NotNan<f64>>>;
  function from (line 30) | fn from(item: &mut MaxFloatTransType) -> Self {
  function max_n_float_trans (line 48) | pub fn max_n_float_trans(
  function max_n_float_rollup_trans (line 64) | pub fn max_n_float_rollup_trans(
  function max_n_float_combine (line 85) | pub fn max_n_float_combine(
  function max_n_float_serialize (line 99) | pub fn max_n_float_serialize(state: Internal) -> bytea {
  function max_n_float_deserialize (line 105) | pub fn max_n_float_deserialize(bytes: bytea, _internal: Internal) -> Opt...
  function max_n_float_final (line 111) | pub fn max_n_float_final(state: Internal) -> MaxFloats<'static> {
  function max_n_float_to_array (line 116) | pub fn max_n_float_to_array(agg: MaxFloats<'static>) -> Vec<f64> {
  function max_n_float_to_values (line 121) | pub fn max_n_float_to_values(agg: MaxFloats<'static>) -> SetOfIterator<'...
  function arrow_max_float_into_values (line 127) | pub fn arrow_max_float_into_values(
  function arrow_max_float_into_array (line 135) | pub fn arrow_max_float_into_array(
  function max_float_correctness (line 197) | fn max_float_correctness() {

FILE: extension/src/nmost/max_int.rs
  type MaxIntTransType (line 16) | type MaxIntTransType = NMostTransState<Reverse<i64>>;
  function from (line 29) | fn from(item: &mut MaxIntTransType) -> Self {
  function max_n_int_trans (line 47) | pub fn max_n_int_trans(
  function max_n_int_rollup_trans (line 63) | pub fn max_n_int_rollup_trans(
  function max_n_int_combine (line 79) | pub fn max_n_int_combine(
  function max_n_int_serialize (line 93) | pub fn max_n_int_serialize(state: Internal) -> bytea {
  function max_n_int_deserialize (line 99) | pub fn max_n_int_deserialize(bytes: bytea, _internal: Internal) -> Optio...
  function max_n_int_final (line 105) | pub fn max_n_int_final(state: Internal) -> MaxInts<'static> {
  function max_n_int_to_array (line 110) | pub fn max_n_int_to_array(agg: MaxInts<'static>) -> Vec<i64> {
  function max_n_int_to_values (line 115) | pub fn max_n_int_to_values(agg: MaxInts<'static>) -> SetOfIterator<'stat...
  function arrow_max_int_into_values (line 121) | pub fn arrow_max_int_into_values(
  function arrow_max_int_into_array (line 129) | pub fn arrow_max_int_into_array(agg: MaxInts<'static>, _accessor: Access...
  function max_int_correctness (line 188) | fn max_int_correctness() {

FILE: extension/src/nmost/max_time.rs
  type MaxTimeTransType (line 16) | type MaxTimeTransType = NMostTransState<Reverse<pg_sys::TimestampTz>>;
  function from (line 29) | fn from(item: &mut MaxTimeTransType) -> Self {
  function max_n_time_trans (line 47) | pub fn max_n_time_trans(
  function max_n_time_rollup_trans (line 63) | pub fn max_n_time_rollup_trans(
  function max_n_time_combine (line 80) | pub fn max_n_time_combine(
  function max_n_time_serialize (line 94) | pub fn max_n_time_serialize(state: Internal) -> bytea {
  function max_n_time_deserialize (line 100) | pub fn max_n_time_deserialize(bytes: bytea, _internal: Internal) -> Opti...
  function max_n_time_final (line 106) | pub fn max_n_time_final(state: Internal) -> MaxTimes<'static> {
  function max_n_time_to_array (line 111) | pub fn max_n_time_to_array(agg: MaxTimes<'static>) -> Vec<crate::raw::Ti...
  function max_n_time_to_values (line 120) | pub fn max_n_time_to_values(
  function arrow_max_time_into_values (line 133) | pub fn arrow_max_time_into_values(
  function arrow_max_time_into_array (line 141) | pub fn arrow_max_time_into_array(
  function max_time_correctness (line 203) | fn max_time_correctness() {

FILE: extension/src/nmost/min_by_float.rs
  type MinByFloatTransType (line 14) | type MinByFloatTransType = NMostByTransState<NotNan<f64>>;
  function from (line 26) | fn from(item: MinByFloatTransType) -> Self {
  function min_n_by_float_trans (line 47) | pub fn min_n_by_float_trans(
  function min_n_by_float_rollup_trans (line 65) | pub fn min_n_by_float_rollup_trans(
  function min_n_by_float_final (line 88) | pub fn min_n_by_float_final(state: Internal) -> MinByFloats<'static> {
  function min_n_by_float_to_values (line 93) | pub fn min_n_by_float_to_values(
  function min_by_float_correctness (line 141) | fn min_by_float_correctness() {

FILE: extension/src/nmost/min_by_int.rs
  type MinByIntTransType (line 12) | type MinByIntTransType = NMostByTransState<i64>;
  function from (line 24) | fn from(item: MinByIntTransType) -> Self {
  function min_n_by_int_trans (line 41) | pub fn min_n_by_int_trans(
  function min_n_by_int_rollup_trans (line 59) | pub fn min_n_by_int_rollup_trans(
  function min_n_by_int_final (line 75) | pub fn min_n_by_int_final(state: Internal) -> MinByInts<'static> {
  function min_n_by_int_to_values (line 80) | pub fn min_n_by_int_to_values(
  function min_by_int_correctness (line 128) | fn min_by_int_correctness() {

FILE: extension/src/nmost/min_by_time.rs
  type MinByTimeTransType (line 12) | type MinByTimeTransType = NMostByTransState<pg_sys::TimestampTz>;
  function from (line 24) | fn from(item: MinByTimeTransType) -> Self {
  function min_n_by_time_trans (line 41) | pub fn min_n_by_time_trans(
  function min_n_by_time_rollup_trans (line 59) | pub fn min_n_by_time_rollup_trans(
  function min_n_by_time_final (line 75) | pub fn min_n_by_time_final(state: Internal) -> MinByTimes<'static> {
  function min_n_by_time_to_values (line 80) | pub fn min_n_by_time_to_values(
  function min_by_time_correctness (line 135) | fn min_by_time_correctness() {

FILE: extension/src/nmost/min_float.rs
  type MinFloatTransType (line 16) | type MinFloatTransType = NMostTransState<NotNan<f64>>;
  function from (line 29) | fn from(item: &mut MinFloatTransType) -> Self {
  function min_n_float_trans (line 47) | pub fn min_n_float_trans(
  function min_n_float_rollup_trans (line 63) | pub fn min_n_float_rollup_trans(
  function min_n_float_combine (line 84) | pub fn min_n_float_combine(
  function min_n_float_serialize (line 98) | pub fn min_n_float_serialize(state: Internal) -> bytea {
  function min_n_float_deserialize (line 104) | pub fn min_n_float_deserialize(bytes: bytea, _internal: Internal) -> Opt...
  function min_n_float_final (line 110) | pub fn min_n_float_final(state: Internal) -> MinFloats<'static> {
  function min_n_float_to_array (line 115) | pub fn min_n_float_to_array(agg: MinFloats<'static>) -> Vec<f64> {
  function min_n_float_to_values (line 120) | pub fn min_n_float_to_values(agg: MinFloats<'static>) -> SetOfIterator<'...
  function arrow_min_float_into_values (line 126) | pub fn arrow_min_float_into_values(
  function arrow_min_float_into_array (line 134) | pub fn arrow_min_float_into_array(
  function min_float_correctness (line 196) | fn min_float_correctness() {

FILE: extension/src/nmost/min_int.rs
  type MinIntTransType (line 14) | type MinIntTransType = NMostTransState<i64>;
  function from (line 27) | fn from(item: &mut MinIntTransType) -> Self {
  function min_n_int_trans (line 40) | pub fn min_n_int_trans(
  function min_n_int_rollup_trans (line 56) | pub fn min_n_int_rollup_trans(
  function min_n_int_combine (line 71) | pub fn min_n_int_combine(
  function min_n_int_serialize (line 85) | pub fn min_n_int_serialize(state: Internal) -> bytea {
  function min_n_int_deserialize (line 91) | pub fn min_n_int_deserialize(bytes: bytea, _internal: Internal) -> Optio...
  function min_n_int_final (line 97) | pub fn min_n_int_final(state: Internal) -> MinInts<'static> {
  function min_n_int_to_array (line 102) | pub fn min_n_int_to_array(agg: MinInts<'static>) -> Vec<i64> {
  function min_n_int_to_values (line 107) | pub fn min_n_int_to_values(agg: MinInts<'static>) -> SetOfIterator<'stat...
  function arrow_min_int_into_values (line 113) | pub fn arrow_min_int_into_values(
  function arrow_min_int_into_array (line 121) | pub fn arrow_min_int_into_array(agg: MinInts<'static>, _accessor: Access...
  function min_int_correctness (line 180) | fn min_int_correctness() {

FILE: extension/src/nmost/min_time.rs
  type MinTimeTransType (line 14) | type MinTimeTransType = NMostTransState<pg_sys::TimestampTz>;
  function from (line 27) | fn from(item: &mut MinTimeTransType) -> Self {
  function min_n_time_trans (line 40) | pub fn min_n_time_trans(
  function min_n_time_rollup_trans (line 56) | pub fn min_n_time_rollup_trans(
  function min_n_time_combine (line 71) | pub fn min_n_time_combine(
  function min_n_time_serialize (line 85) | pub fn min_n_time_serialize(state: Internal) -> bytea {
  function min_n_time_deserialize (line 91) | pub fn min_n_time_deserialize(bytes: bytea, _internal: Internal) -> Opti...
  function min_n_time_final (line 97) | pub fn min_n_time_final(state: Internal) -> MinTimes<'static> {
  function min_n_time_to_array (line 102) | pub fn min_n_time_to_array(agg: MinTimes<'static>) -> Vec<crate::raw::Ti...
  function min_n_time_to_values (line 111) | pub fn min_n_time_to_values(
  function arrow_min_time_into_values (line 124) | pub fn arrow_min_time_into_values(
  function arrow_min_time_into_array (line 132) | pub fn arrow_min_time_into_array(
  function min_time_correctness (line 194) | fn min_time_correctness() {

FILE: extension/src/palloc.rs
  function in_memory_context (line 9) | pub unsafe fn in_memory_context<T, F: FnOnce() -> T>(mctx: pg_sys::Memor...
  type InternalAsValue (line 27) | pub unsafe trait InternalAsValue {
    method to_inner (line 29) | unsafe fn to_inner<T>(self) -> Option<Inner<T>>;
    method to_inner (line 42) | unsafe fn to_inner<T>(self) -> Option<Inner<T>> {
  type ToInternal (line 53) | pub unsafe trait ToInternal {
    method internal (line 54) | fn internal(self) -> Option<Internal>;
    method internal (line 74) | fn internal(self) -> Option<Internal> {
    method internal (line 80) | fn internal(self) -> Option<Internal> {
    method internal (line 93) | fn internal(self) -> Option<Internal> {
    method internal (line 99) | fn internal(self) -> Option<Internal> {
  type Inner (line 57) | pub struct Inner<T>(pub NonNull<T>);
  type Target (line 60) | type Target = T;
  method deref (line 62) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 68) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 86) | fn from(t: T) -> Self {
  type PanickingAllocator (line 127) | struct PanickingAllocator;
  method alloc (line 133) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
  method dealloc (line 141) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
  method alloc_zeroed (line 145) | unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
  method realloc (line 153) | unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) ...

FILE: extension/src/pg_any_element.rs
  type PgAnyElement (line 14) | pub struct PgAnyElement {
    method deep_copy_datum (line 27) | pub fn deep_copy_datum(&self) -> Datum {
    method from (line 83) | fn from(other: (Datum, Oid)) -> Self {
    method from (line 90) | fn from(other: AnyElement) -> Self {
  method eq (line 34) | fn eq(&self, other: &Self) -> bool {
  method hash (line 77) | fn hash<H: Hasher>(&self, state: &mut H) {
  type PgAnyElementHashMap (line 98) | pub struct PgAnyElementHashMap<V>(pub(crate) HashMap<PgAnyElement, V, Da...
  function new (line 101) | pub fn new(typoid: Oid, collation: Option<Oid>) -> Self {
  function with_hasher (line 107) | pub(crate) fn with_hasher(hasher: DatumHashBuilder) -> Self {
  function typoid (line 111) | pub fn typoid(&self) -> Oid {
  function contains_key (line 116) | pub fn contains_key(&self, k: &PgAnyElement) -> bool {
  function get (line 119) | pub fn get(&self, k: &PgAnyElement) -> Option<&V> {
  function get_mut (line 122) | pub fn get_mut(&mut self, k: &PgAnyElement) -> Option<&mut V> {
  function hasher (line 125) | pub(crate) fn hasher(&self) -> &DatumHashBuilder {
  function insert (line 128) | pub fn insert(&mut self, k: PgAnyElement, v: V) -> Option<V> {
  function len (line 131) | pub fn len(&self) -> usize {
  function remove (line 134) | pub fn remove(&mut self, k: &PgAnyElement) -> Option<V> {

FILE: extension/src/range.rs
  type tstzrange (line 10) | pub type tstzrange = *mut pg_sys::varlena;
  function get_range (line 15) | pub unsafe fn get_range(range: tstzrange) -> Option<I64Range> {
  function get_toasted_bytes (line 46) | unsafe fn get_toasted_bytes(ptr: &pg_sys::varlena) -> &[u8] {
  constant RANGE_EMPTY (line 55) | const RANGE_EMPTY: u8 = 0x01;
  constant RANGE_LB_INC (line 56) | const RANGE_LB_INC: u8 = 0x02;
  constant RANGE_UB_INC (line 57) | const RANGE_UB_INC: u8 = 0x04;
  constant RANGE_LB_INF (line 58) | const RANGE_LB_INF: u8 = 0x08;
  constant RANGE_UB_INF (line 59) | const RANGE_UB_INF: u8 = 0x10;
  constant RANGE_LB_NULL (line 60) | const RANGE_LB_NULL: u8 = 0x20;
  constant RANGE_UB_NULL (line 61) | const RANGE_UB_NULL: u8 = 0x40;
  function range_has_lbound (line 63) | fn range_has_lbound(flags: u8) -> bool {
  function lbound_inclusive (line 67) | fn lbound_inclusive(flags: u8) -> bool {
  function range_has_rbound (line 71) | fn range_has_rbound(flags: u8) -> bool {
  function rbound_inclusive (line 74) | fn rbound_inclusive(flags: u8) -> bool {
  method to_i64range (line 106) | pub fn to_i64range(&self) -> Option<I64Range> {
  method from_i64range (line 116) | pub fn from_i64range(b: Option<I64Range>) -> Self {

FILE: extension/src/raw.rs
  type bytea (line 93) | pub struct bytea(pub pg_sys::Datum);
    method box_into (line 98) | unsafe fn box_into<'fcx>(
  type text (line 107) | pub struct text(pub pg_sys::Datum);
  type TimestampTz (line 111) | pub struct TimestampTz(pub pg_sys::Datum);
    method box_into (line 120) | unsafe fn box_into<'fcx>(
    method from (line 135) | fn from(ts: pg_sys::TimestampTz) -> Self {
  function from (line 129) | fn from(tstz: TimestampTz) -> Self {
  type AnyElement (line 140) | pub struct AnyElement(pub pg_sys::Datum);
  type tstzrange (line 144) | pub struct tstzrange(pub pg_sys::Datum);
  type Interval (line 148) | pub struct Interval(pub pg_sys::Datum);
    method box_into (line 153) | unsafe fn box_into<'fcx>(
    method from (line 162) | fn from(interval: i64) -> Self {
  type regproc (line 191) | pub struct regproc(pub pg_sys::Datum);

FILE: extension/src/saturation.rs
  function saturating_add (line 7) | fn saturating_add(x: i32, y: i32) -> i32 {
  function saturating_add_pos (line 13) | fn saturating_add_pos(x: i32, y: i32) -> i32 {
  function saturating_sub (line 25) | fn saturating_sub(x: i32, y: i32) -> i32 {
  function saturating_sub_pos (line 31) | fn saturating_sub_pos(x: i32, y: i32) -> i32 {
  function saturating_mul (line 41) | fn saturating_mul(x: i32, y: i32) -> i32 {
  function test_saturating_add_max (line 53) | fn test_saturating_add_max() {
  function test_saturating_add_min (line 59) | fn test_saturating_add_min() {
  function test_saturating_add_pos (line 65) | fn test_saturating_add_pos() {
  function test_saturating_sub_max (line 71) | fn test_saturating_sub_max() {
  function test_saturating_sub_min (line 77) | fn test_saturating_sub_min() {
  function test_saturating_sub_pos (line 83) | fn test_saturating_sub_pos() {
  function test_saturating_mul_max (line 89) | fn test_saturating_mul_max() {
  function test_saturating_mul_min (line 95) | fn test_saturating_mul_min() {

FILE: extension/src/serialization.rs
  function _ts_toolkit_encode_timestamptz (line 19) | pub extern "C" fn _ts_toolkit_encode_timestamptz(
  function _ts_toolkit_decode_timestamptz (line 57) | pub extern "C" fn _ts_toolkit_decode_timestamptz(text: &str) -> i64 {
  type EncodedStr (line 143) | pub enum EncodedStr<'s> {
  function str_to_db_encoding (line 148) | pub fn str_to_db_encoding(s: &str) -> EncodedStr<'_> {
  function str_from_db_encoding (line 169) | pub fn str_from_db_encoding(s: &CStr) -> &str {
  function default_padding (line 185) | pub(crate) fn default_padding() -> [u8; 3] {
  function default_header (line 189) | pub(crate) fn default_header() -> u32 {

FILE: extension/src/serialization/collations.rs
  type PgCollationId (line 23) | pub struct PgCollationId(pub Oid);
    method is_invalid (line 28) | pub fn is_invalid(&self) -> bool {
    method to_option_oid (line 32) | pub fn to_option_oid(self) -> Option<Oid> {
    method deserialize (line 167) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  constant Anum_pg_collation_oid (line 42) | const Anum_pg_collation_oid: u32 = 1;
  constant DEFAULT_COLLATION_OID (line 45) | pub(crate) const DEFAULT_COLLATION_OID: Oid = unsafe { Oid::from_u32_unc...
  type FormData_pg_collation (line 50) | struct FormData_pg_collation {
  type Form_pg_collation (line 63) | type Form_pg_collation = *mut FormData_pg_collation;
  type FormData_pg_database (line 68) | struct FormData_pg_database {
  type Form_pg_database (line 78) | type Form_pg_database = *mut FormData_pg_database;
  method serialize (line 103) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function get_struct (line 248) | unsafe fn get_struct<T>(tuple: pg_sys::HeapTuple) -> *mut T {
  constant COLLATION_ID_950 (line 263) | const COLLATION_ID_950: PgCollationId =
  constant COLLATION_ID_951 (line 266) | const COLLATION_ID_951: PgCollationId =
  function test_pg_collation_id_serialize_default_collation_ron (line 271) | fn test_pg_collation_id_serialize_default_collation_ron() {
  function test_pg_collation_id_serialize_c_collation (line 287) | fn test_pg_collation_id_serialize_c_collation() {
  function test_pg_collation_id_serialize_c_collation_ron (line 302) | fn test_pg_collation_id_serialize_c_collation_ron() {
  function test_pg_collation_id_serialize_posix_collation (line 310) | fn test_pg_collation_id_serialize_posix_collation() {
  function test_pg_collation_id_serialize_posix_collation_ron (line 325) | fn test_pg_collation_id_serialize_posix_collation_ron() {

FILE: extension/src/serialization/functions.rs
  type PgProcId (line 19) | pub struct PgProcId(pub Oid);
    method deserialize (line 47) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function format_procedure_qualified (line 26) | pub fn format_procedure_qualified(procedure_oid: pg_sys::Oid) -> *const ...
  method serialize (line 30) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: extension/src/serialization/types.rs
  type ShortTypeId (line 20) | pub struct ShortTypeId(pub Oid);
    method from (line 25) | fn from(id: Oid) -> Self {
    method deserialize (line 46) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method from (line 31) | fn from(id: ShortTypeId) -> Self {
  method serialize (line 37) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type ShortTypIdSerializer (line 57) | enum ShortTypIdSerializer {
    method from_oid (line 105) | pub fn from_oid(oid: Oid) -> Self {
    method to_oid (line 154) | pub fn to_oid(&self) -> Oid {
  type PgTypId (line 208) | pub struct PgTypId(pub Oid);
    method deserialize (line 259) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 211) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function get_struct (line 310) | unsafe fn get_struct<T>(tuple: pg_sys::HeapTuple) -> *mut T {
  function test_pg_type_id_serialize_char_type (line 328) | fn test_pg_type_id_serialize_char_type() {
  function test_pg_type_id_serialize_char_type_ron (line 342) | fn test_pg_type_id_serialize_char_type_ron() {
  function test_pg_type_id_serialize_bool_type (line 350) | fn test_pg_type_id_serialize_bool_type() {
  function test_pg_type_id_serialize_bool_type_ron (line 363) | fn test_pg_type_id_serialize_bool_type_ron() {
  function test_short_type_id_serialize_char_type (line 371) | fn test_short_type_id_serialize_char_type() {
  function test_short_type_id_serialize_char_type_ron (line 379) | fn test_short_type_id_serialize_char_type_ron() {
  function test_short_type_id_serialize_bool_type (line 387) | fn test_short_type_id_serialize_bool_type() {
  function test_short_type_id_serialize_bool_type_ron (line 395) | fn test_short_type_id_serialize_bool_type_ron() {
  function test_short_type_id_serialize_circle_type (line 403) | fn test_short_type_id_serialize_circle_type() {
  function test_short_type_id_serialize_circle_type_ron (line 417) | fn test_short_type_id_serialize_circle_type_ron() {

FILE: extension/src/stabilization_tests.rs
  function test_schema_qualification (line 14) | fn test_schema_qualification() {
  function stable_functions (line 153) | fn stable_functions() -> HashSet<String> {
  function stable_types (line 157) | fn stable_types() -> HashSet<String> {
  function stable_operators (line 161) | fn stable_operators() -> HashSet<String> {

FILE: extension/src/state_aggregate.rs
  type MaterializedState (line 37) | enum MaterializedState {
    method entry (line 42) | fn entry(&self, states: &mut String) -> StateEntry {
    method existing_entry (line 48) | fn existing_entry(&self, states: &str) -> StateEntry {
    method into_string (line 55) | fn into_string(self) -> String {
    method into_integer (line 61) | fn into_integer(self) -> i64 {
  type StateEntry (line 74) | pub struct StateEntry {
    method from_integer (line 80) | fn from_integer(int: i64) -> Self {
    method from_str (line 86) | fn from_str(states: &mut String, new_state: &str) -> Self {
    method from_existing_str (line 99) | fn from_existing_str(states: &str, state: &str) -> Self {
    method try_from_existing_str (line 106) | fn try_from_existing_str(states: &str, state: &str) -> Option<Self> {
    method materialize (line 116) | fn materialize(&self, states: &str) -> MaterializedState {
    method as_str (line 129) | fn as_str(self, states: &str) -> &str {
    method into_integer (line 136) | fn into_integer(self) -> i64 {
  function empty (line 165) | pub(super) fn empty(compact: bool, integer_states: bool) -> Self {
  function new (line 184) | pub(super) fn new(
  function get (line 250) | pub fn get(&self, state: StateEntry) -> Option<i64> {
  function get_materialized (line 253) | pub(super) fn get_materialized(&self, state: &MaterializedState) -> Opti...
  function states_as_str (line 262) | pub(super) fn states_as_str(&self) -> &str {
  function interpolate (line 268) | pub(super) fn interpolate(
  function assert_int (line 399) | pub fn assert_int<'a>(&self) {
  function assert_str (line 405) | pub fn assert_str<'a>(&self) {
  function new (line 423) | pub fn new(compact_state_agg: CompactStateAgg) -> Self {
  function empty (line 431) | pub fn empty(integer_states: bool) -> Self {
  function as_compact_state_agg (line 435) | pub fn as_compact_state_agg(self) -> toolkit_experimental::CompactStateA...
  function assert_int (line 439) | pub fn assert_int<'a>(&self) {
  function assert_str (line 445) | pub fn assert_str<'a>(&self) {
  function state_trans_inner (line 454) | fn state_trans_inner(
  type State (line 470) | type State = CompactStateAggTransState;
  constant PARALLEL_SAFE (line 472) | const PARALLEL_SAFE: bool = true;
  function transition (line 474) | fn transition(
  function combine (line 482) | fn combine(a: Option<&State>, b: Option<&State>) -> Option<State> {
  function serialize (line 494) | fn serialize(state: &mut State) -> bytea {
  function deserialize (line 498) | fn deserialize(bytes: bytea) -> State {
  function finally (line 502) | fn finally(state: Option<&mut State>) -> Option<CompactStateAgg<'static>> {
  function compact_state_agg_int_trans (line 541) | fn compact_state_agg_int_trans(
  type State (line 575) | type State = CompactStateAggTransState;
  constant PARALLEL_SAFE (line 577) | const PARALLEL_SAFE: bool = true;
  method transition (line 579) | fn transition(
  method combine (line 587) | fn combine(a: Option<&State>, b: Option<&State>) -> Option<State> {
  method serialize (line 591) | fn serialize(state: &mut State) -> bytea {
  method deserialize (line 595) | fn deserialize(bytes: bytea) -> State {
  method finally (line 599) | fn finally(state: Option<&mut State>) -> Option<StateAgg<'static>> {
  function state_agg_int_trans (line 667) | fn state_agg_int_trans(
  type CompactStateAggTransState (line 701) | pub struct CompactStateAggTransState {
    method new (line 707) | fn new(integer_states: bool) -> Self {
    method record (line 714) | fn record(&mut self, state: MaterializedState, time: i64) {
    method append (line 718) | fn append(&mut self, other: &mut Self) {
    method sort_records (line 722) | fn sort_records(&mut self) {
    method make_duration_map_and_bounds (line 742) | fn make_duration_map_and_bounds(
  function duration_in_inner (line 763) | fn duration_in_inner<'a>(
  function duration_in (line 809) | pub fn duration_in<'a>(agg: Option<CompactStateAgg<'a>>, state: String) ...
  function duration_in_int (line 823) | pub fn duration_in_int<'a>(agg: Option<CompactStateAgg<'a>>, state: i64)...
  function duration_in_tl (line 831) | pub fn duration_in_tl<'a>(agg: Option<StateAgg<'a>>, state: String) -> c...
  function duration_in_tl_int (line 839) | pub fn duration_in_tl_int<'a>(agg: Option<StateAgg<'a>>, state: i64) -> ...
  function arrow_state_agg_duration_in_string (line 851) | pub fn arrow_state_agg_duration_in_string<'a>(
  function arrow_state_agg_duration_in_int (line 862) | pub fn arrow_state_agg_duration_in_int<'a>(
  function duration_in_range (line 871) | pub fn duration_in_range<'a>(
  function duration_in_range_int (line 891) | pub fn duration_in_range_int<'a>(
  constant NO_INTERVAL_MARKER (line 911) | const NO_INTERVAL_MARKER: i64 = i64::MIN;
  function range_tuple (line 912) | fn range_tuple(start: i64, interval: i64) -> (i64, Option<i64>) {
  function arrow_state_agg_duration_in_range_string (line 924) | pub fn arrow_state_agg_duration_in_range_string<'a>(
  function arrow_state_agg_duration_in_range_int (line 939) | pub fn arrow_state_agg_duration_in_range_int<'a>(
  function interpolated_duration_in_inner (line 951) | fn interpolated_duration_in_inner<'a>(
  function interpolated_duration_in (line 988) | pub fn interpolated_duration_in<'a>(
  function interpolated_duration_in_tl (line 1009) | pub fn interpolated_duration_in_tl<'a>(
  function interpolated_duration_in_int (line 1034) | pub fn interpolated_duration_in_int<'a>(
  function interpolated_duration_in_tl_int (line 1055) | pub fn interpolated_duration_in_tl_int<'a>(
  function arrow_state_agg_interpolated_duration_in_string (line 1075) | pub fn arrow_state_agg_interpolated_duration_in_string<'a>(
  function arrow_state_agg_interpolated_duration_in_int (line 1096) | pub fn arrow_state_agg_interpolated_duration_in_int<'a>(
  function duration_in_bad_args_inner (line 1114) | fn duration_in_bad_args_inner() -> ! {
  function duration_in_bad_args (line 1125) | pub fn duration_in_bad_args<'a>(
  function duration_in_int_bad_args (line 1140) | pub fn duration_in_int_bad_args<'a>(
  function into_values (line 1150) | pub fn into_values<'a>(
  function into_int_values (line 1169) | pub fn into_int_values<'a>(
  function into_values_tl (line 1189) | pub fn into_values_tl<'a>(
  function into_values_tl_int (line 1202) | pub fn into_values_tl_int<'a>(
  function arrow_state_agg_into_values (line 1216) | pub fn arrow_state_agg_into_values<'a>(
  function arrow_state_agg_into_int_values (line 1230) | pub fn arrow_state_agg_into_int_values<'a>(
  function state_timeline_inner (line 1243) | fn state_timeline_inner<'a>(
  function state_int_timeline_inner (line 1271) | fn state_int_timeline_inner<'a>(
  function state_timeline (line 1302) | pub fn state_timeline<'a>(
  function state_int_timeline (line 1316) | pub fn state_int_timeline<'a>(
  function arrow_state_agg_state_timeline (line 1332) | pub fn arrow_state_agg_state_timeline<'a>(
  function arrow_state_agg_state_int_timeline (line 1347) | pub fn arrow_state_agg_state_int_timeline<'a>(
  function interpolated_state_timeline_inner (line 1361) | fn interpolated_state_timeline_inner<'a>(
  function interpolated_state_int_timeline_inner (line 1392) | fn interpolated_state_int_timeline_inner<'a>(
  function interpolated_state_timeline (line 1424) | pub fn interpolated_state_timeline<'a>(
  function interpolated_state_int_timeline (line 1441) | pub fn interpolated_state_int_timeline<'a>(
  function arrow_state_agg_interpolated_state_timeline (line 1459) | pub fn arrow_state_agg_interpolated_state_timeline<'a>(
  function arrow_state_agg_interpolated_state_int_timeline (line 1483) | pub fn arrow_state_agg_interpolated_state_int_timeline<'a>(
  function state_periods_inner (line 1506) | fn state_periods_inner<'a>(
  function state_periods (line 1539) | pub fn state_periods<'a>(
  function state_int_periods (line 1554) | pub fn state_int_periods<'a>(
  function arrow_state_agg_state_periods_string (line 1573) | pub fn arrow_state_agg_state_periods_string<'a>(
  function arrow_state_agg_state_periods_int (line 1590) | pub fn arrow_state_agg_state_periods_int<'a>(
  function interpolated_state_periods_inner (line 1604) | fn interpolated_state_periods_inner<'a>(
  function interpolated_state_periods (line 1629) | pub fn interpolated_state_periods<'a>(
  function interpolated_state_periods_int (line 1655) | pub fn interpolated_state_periods_int<'a>(
  function arrow_state_agg_interpolated_state_periods_string (line 1682) | pub fn arrow_state_agg_interpolated_state_periods_string<'a>(
  function arrow_state_agg_interpolated_state_periods_int (line 1709) | pub fn arrow_state_agg_interpolated_state_periods_int<'a>(
  function state_at_inner (line 1733) | fn state_at_inner<'a>(agg: StateAgg<'a>, point: i64) -> Option<Materiali...
  function state_at (line 1752) | fn state_at<'a>(agg: StateAgg<'a>, point: TimestampTz) -> Option<String> {
  function state_at_int (line 1758) | fn state_at_int<'a>(agg: StateAgg<'a>, point: TimestampTz) -> Option<i64> {
  function arrow_state_agg_state_at_string (line 1765) | pub fn arrow_state_agg_state_at_string<'a>(
  function arrow_state_agg_state_at_int (line 1774) | pub fn arrow_state_agg_state_at_int<'a>(
  type DurationInState (line 1783) | pub struct DurationInState {
  type TimeInState (line 1790) | pub struct TimeInState {
  type DurationState (line 1796) | struct DurationState {
    method new (line 1801) | fn new() -> Self {
    method handle_record (line 1808) | fn handle_record(&mut self, state: MaterializedState, time: i64) {
    method finalize (line 1830) | fn finalize(&mut self) {
  type Record (line 1838) | struct Record {
  function duration_in_misuse_error (line 1865) | fn duration_in_misuse_error() {
  function one_state_one_change (line 1882) | fn one_state_one_change() {
  function two_states_two_changes (line 1917) | fn two_states_two_changes() {
  function two_states_three_changes (line 1954) | fn two_states_three_changes() {
  function out_of_order_times (line 2009) | fn out_of_order_times() {
  function same_state_twice (line 2047) | fn same_state_twice() {
  function duration_in_two_states_two_changes (line 2086) | fn duration_in_two_states_two_changes() {
  function same_state_twice_last (line 2122) | fn same_state_twice_last() {
  function combine_using_muchos_data (line 2150) | fn combine_using_muchos_data() {
  function combine_using_settings (line 2187) | fn combine_using_settings() {
  function sample_query (line 2233) | fn sample_query() {
  function interpolated_duration (line 2282) | fn interpolated_duration() {
  function two_states_at_one_time (line 2462) | fn two_states_at_one_time() {
  function interpolate_introduces_state (line 2494) | fn interpolate_introduces_state() {
  function text_serialization (line 2627) | fn text_serialization() {
  function combine (line 2669) | fn combine() {
  function binary_serialization_integer (line 2698) | fn binary_serialization_integer() {
  function binary_serialization_string (line 2735) | fn binary_serialization_string() {

FILE: extension/src/state_aggregate/accessors.rs
  function accessor_state_agg_interpolated_interpolated_state_timeline (line 20) | fn accessor_state_agg_interpolated_interpolated_state_timeline<'a>(
  function accessor_state_agg_interpolated_interpolated_state_int_timeline (line 46) | fn accessor_state_agg_interpolated_interpolated_state_int_timeline<'a>(
  function accessor_state_agg_interpolated_interpolated_duration_in (line 87) | fn accessor_state_agg_interpolated_interpolated_duration_in<'a>(
  function accessor_state_agg_interpolated_interpolated_duration_in_int (line 106) | fn accessor_state_agg_interpolated_interpolated_duration_in_int<'a>(
  function accessor_state_agg_interpolated_interpolated_state_periods (line 150) | fn accessor_state_agg_interpolated_interpolated_state_periods<'a>(
  function accessor_state_agg_interpolated_interpolated_state_periods_int (line 169) | fn accessor_state_agg_interpolated_interpolated_state_periods_int<'a>(
  function accessor_state_agg_duration_in (line 202) | fn accessor_state_agg_duration_in(state: String) -> AccessorDurationIn<'...
  function accessor_state_agg_duration_in_int (line 211) | fn accessor_state_agg_duration_in_int(state: i64) -> AccessorDurationInI...
  function accessor_state_agg_state_periods (line 234) | fn accessor_state_agg_state_periods<'a>(state: String) -> AccessorStateP...
  function accessor_state_agg_state_periods_int (line 243) | fn accessor_state_agg_state_periods_int(state: i64) -> AccessorStatePeri...
  function accessor_state_agg_duration_in_range (line 271) | fn accessor_state_agg_duration_in_range(
  function accessor_state_agg_duration_in_range_int (line 290) | fn accessor_state_agg_duration_in_range_int(
  function accessor_state_agg_state_at (line 315) | fn accessor_state_agg_state_at(time: TimestampTz) -> AccessorStateAt {
  function accessor_state_agg_state_at_int (line 331) | fn accessor_state_agg_state_at_int(time: TimestampTz) -> AccessorStateAt...

FILE: extension/src/state_aggregate/rollup.rs
  type RollupTransState (line 54) | pub struct RollupTransState {
    method merge (line 267) | fn merge(&mut self) {
  type OwnedCompactStateAgg (line 60) | struct OwnedCompactStateAgg {
    method merge (line 73) | pub fn merge(self, other: Self) -> Self {
    method from (line 238) | fn from(agg: CompactStateAgg<'a>) -> OwnedCompactStateAgg {
  function from (line 217) | fn from(owned: OwnedCompactStateAgg) -> CompactStateAgg<'a> {
  method partial_cmp (line 254) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 260) | fn cmp(&self, other: &Self) -> Ordering {
  function compact_state_agg_rollup_trans (line 280) | pub fn compact_state_agg_rollup_trans(
  function compact_state_agg_rollup_trans_inner (line 288) | pub fn compact_state_agg_rollup_trans_inner(
  function state_agg_rollup_trans (line 313) | pub fn state_agg_rollup_trans(
  function compact_state_agg_rollup_final (line 327) | fn compact_state_agg_rollup_final(
  function compact_state_agg_rollup_final_inner (line 334) | fn compact_state_agg_rollup_final_inner(
  function state_agg_rollup_final (line 353) | fn state_agg_rollup_final(
  function state_agg_rollup_final_inner (line 360) | fn state_agg_rollup_final_inner(
  function state_agg_rollup_serialize (line 379) | pub fn state_agg_rollup_serialize(state: Internal) -> bytea {
  function state_agg_rollup_deserialize (line 386) | pub fn state_agg_rollup_deserialize(bytes: bytea, _internal: Internal) -...
  function state_agg_rollup_deserialize_inner (line 389) | pub fn state_agg_rollup_deserialize_inner(bytes: bytea) -> Inner<RollupT...
  function state_agg_rollup_combine (line 395) | pub fn state_agg_rollup_combine(
  function state_agg_rollup_combine_inner (line 406) | pub fn state_agg_rollup_combine_inner(
  function merge_range_full_overlap (line 443) | fn merge_range_full_overlap() {
  function merge_range_partial_overlap (line 457) | fn merge_range_partial_overlap() {
  function merges_compact_aggs_correctly (line 470) | fn merges_compact_aggs_correctly() {

FILE: extension/src/stats_agg.rs
  type StatsSummary1DTF (line 26) | type StatsSummary1DTF = InternalStatsSummary1D<TwoFloat>;
  type StatsSummary2DTF (line 27) | type StatsSummary2DTF = InternalStatsSummary2D<TwoFloat>;
  method to_internal (line 60) | fn to_internal(&self) -> InternalStatsSummary1D<f64> {
  method from_internal (line 69) | pub fn from_internal(st: InternalStatsSummary1D<f64>) -> Self {
  method to_internal (line 81) | fn to_internal(&self) -> InternalStatsSummary2D<f64> {
  method from_internal (line 95) | fn from_internal(st: InternalStatsSummary2D<f64>) -> Self {
  function stats1d_trans_serialize (line 112) | pub fn stats1d_trans_serialize(state: Internal) -> bytea {
  function stats1d_trans_deserialize (line 119) | pub fn stats1d_trans_deserialize(bytes: bytea, _internal: Internal) -> O...
  function stats1d_trans_deserialize_inner (line 122) | pub fn stats1d_trans_deserialize_inner(bytes: bytea) -> Inner<StatsSumma...
  function stats2d_trans_serialize (line 128) | pub fn stats2d_trans_serialize(state: Internal) -> bytea {
  function stats2d_trans_deserialize (line 135) | pub fn stats2d_trans_deserialize(bytes: bytea, _internal: Internal) -> O...
  function stats2d_trans_deserialize_inner (line 138) | pub fn stats2d_trans_deserialize_inner(bytes: bytea) -> Inner<StatsSumma...
  function stats1d_trans (line 144) | pub fn stats1d_trans(
  function stats1d_tf_trans (line 152) | pub fn stats1d_tf_trans(
  function stats1d_trans_inner (line 159) | pub fn stats1d_trans_inner(
  function stats1d_tf_trans_inner (line 186) | pub fn stats1d_tf_trans_inner(
  function stats2d_trans (line 215) | pub fn stats2d_trans(
  function stats2d_trans_inner (line 223) | pub fn stats2d_trans_inner(
  function stats2d_tf_trans (line 259) | pub fn stats2d_tf_trans(
  function stats2d_tf_trans_inner (line 267) | pub fn stats2d_tf_trans_inner(
  function stats1d_inv_trans (line 306) | pub fn stats1d_inv_trans(
  function stats1d_inv_trans_inner (line 313) | pub fn stats1d_inv_trans_inner(
  function stats1d_tf_inv_trans (line 332) | pub fn stats1d_tf_inv_trans(
  function stats1d_tf_inv_trans_inner (line 339) | pub fn stats1d_tf_inv_trans_inner(
  function stats2d_inv_trans (line 358) | pub fn stats2d_inv_trans(
  function stats2d_inv_trans_inner (line 366) | pub fn stats2d_inv_trans_inner(
  function stats2d_tf_inv_trans (line 393) | pub fn stats2d_tf_inv_trans(
  function stats2d_tf_inv_trans_inner (line 401) | pub fn stats2d_tf_inv_trans_inner(
  function stats1d_summary_trans (line 431) | pub fn stats1d_summary_trans(
  function stats1d_summary_trans_inner (line 438) | pub fn stats1d_summary_trans_inner(
  function stats2d_summary_trans (line 459) | pub fn stats2d_summary_trans(
  function stats2d_summary_trans_inner (line 466) | pub fn stats2d_summary_trans_inner(
  function stats1d_summary_inv_trans (line 487) | pub fn stats1d_summary_inv_trans(
  function stats1d_summary_inv_trans_inner (line 494) | pub fn stats1d_summary_inv_trans_inner(
  function stats2d_summary_inv_trans (line 514) | pub fn stats2d_summary_inv_trans(
  function stats2d_summary_inv_trans_inner (line 521) | pub fn stats2d_summary_inv_trans_inner(
  function stats1d_combine (line 541) | pub fn stats1d_combine(
  function stats1d_combine_inner (line 548) | pub fn stats1d_combine_inner(
  function stats2d_combine (line 575) | pub fn stats2d_combine(
  function stats2d_combine_inner (line 582) | pub fn stats2d_combine_inner(
  function stats1d_final (line 609) | fn stats1d_final(state: Internal, fcinfo: pg_sys::FunctionCallInfo) -> O...
  function stats1d_tf_final (line 622) | fn stats1d_tf_final(
  function stats2d_final (line 642) | fn stats2d_final(state: Internal, fcinfo: pg_sys::FunctionCallInfo) -> O...
  function stats2d_tf_final (line 655) | fn stats2d_tf_final(state: Internal, fcinfo: pg_sys::FunctionCallInfo) -...
  function arrow_stats1d_average (line 930) | pub fn arrow_stats1d_average(sketch: StatsSummary1D, _accessor: Accessor...
  function stats1d_average (line 935) | pub(crate) fn stats1d_average(summary: StatsSummary1D) -> Option<f64> {
  function arrow_stats1d_sum (line 941) | pub fn arrow_stats1d_sum(sketch: StatsSummary1D, _accessor: AccessorSum)...
  function stats1d_sum (line 946) | pub(crate) fn stats1d_sum(summary: StatsSummary1D) -> Option<f64> {
  function arrow_stats1d_stddev (line 952) | pub fn arrow_stats1d_stddev(
  function stats1d_stddev (line 960) | fn stats1d_stddev(
  function arrow_stats1d_variance (line 972) | pub fn arrow_stats1d_variance(
  function stats1d_variance (line 980) | fn stats1d_variance(
  function arrow_stats1d_skewness (line 992) | pub fn arrow_stats1d_skewness(sketch: StatsSummary1D, accessor: Accessor...
  function stats1d_skewness (line 997) | fn stats1d_skewness(summary: StatsSummary1D, method: default!(&str, "'sa...
  function arrow_stats1d_kurtosis (line 1006) | pub fn arrow_stats1d_kurtosis(sketch: StatsSummary1D, accessor: Accessor...
  function stats1d_kurtosis (line 1011) | fn stats1d_kurtosis(summary: StatsSummary1D, method: default!(&str, "'sa...
  function arrow_stats1d_num_vals (line 1020) | pub fn arrow_stats1d_num_vals(sketch: StatsSummary1D, _accessor: Accesso...
  function stats1d_num_vals (line 1025) | fn stats1d_num_vals(summary: StatsSummary1D) -> i64 {
  function arrow_stats2d_average_x (line 1031) | pub fn arrow_stats2d_average_x(sketch: StatsSummary2D, _accessor: Access...
  function stats2d_average_x (line 1036) | fn stats2d_average_x(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_average_y (line 1042) | pub fn arrow_stats2d_average_y(sketch: StatsSummary2D, _accessor: Access...
  function stats2d_average_y (line 1047) | fn stats2d_average_y(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_sum_x (line 1053) | pub fn arrow_stats2d_sum_x(sketch: StatsSummary2D, _accessor: AccessorSu...
  function stats2d_sum_x (line 1058) | fn stats2d_sum_x(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_sum_y (line 1064) | pub fn arrow_stats2d_sum_y(sketch: StatsSummary2D, _accessor: AccessorSu...
  function stats2d_sum_y (line 1069) | fn stats2d_sum_y(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_stdddev_x (line 1075) | pub fn arrow_stats2d_stdddev_x(
  function stats2d_stddev_x (line 1083) | fn stats2d_stddev_x(
  function arrow_stats2d_stdddev_y (line 1095) | pub fn arrow_stats2d_stdddev_y(
  function stats2d_stddev_y (line 1103) | fn stats2d_stddev_y(
  function arrow_stats2d_variance_x (line 1115) | pub fn arrow_stats2d_variance_x(
  function stats2d_variance_x (line 1123) | fn stats2d_variance_x(
  function arrow_stats2d_variance_y (line 1135) | pub fn arrow_stats2d_variance_y(
  function stats2d_variance_y (line 1143) | fn stats2d_variance_y(
  function arrow_stats2d_skewness_x (line 1155) | pub fn arrow_stats2d_skewness_x(
  function stats2d_skewness_x (line 1163) | fn stats2d_skewness_x(summary: StatsSummary2D, method: default!(&str, "'...
  function arrow_stats2d_skewness_y (line 1172) | pub fn arrow_stats2d_skewness_y(
  function stats2d_skewness_y (line 1180) | fn stats2d_skewness_y(summary: StatsSummary2D, method: default!(&str, "'...
  function arrow_stats2d_kurtosis_x (line 1189) | pub fn arrow_stats2d_kurtosis_x(
  function stats2d_kurtosis_x (line 1197) | fn stats2d_kurtosis_x(summary: StatsSummary2D, method: default!(&str, "'...
  function arrow_stats2d_kurtosis_y (line 1206) | pub fn arrow_stats2d_kurtosis_y(
  function stats2d_kurtosis_y (line 1214) | fn stats2d_kurtosis_y(summary: StatsSummary2D, method: default!(&str, "'...
  function arrow_stats2d_num_vals (line 1223) | pub fn arrow_stats2d_num_vals(sketch: StatsSummary2D, _accessor: Accesso...
  function stats2d_num_vals (line 1228) | fn stats2d_num_vals(summary: StatsSummary2D) -> i64 {
  function arrow_stats2d_slope (line 1234) | pub fn arrow_stats2d_slope(sketch: StatsSummary2D, _accessor: AccessorSl...
  function stats2d_slope (line 1239) | fn stats2d_slope(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_corr (line 1245) | pub fn arrow_stats2d_corr(sketch: StatsSummary2D, _accessor: AccessorCor...
  function stats2d_corr (line 1250) | fn stats2d_corr(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_intercept (line 1256) | pub fn arrow_stats2d_intercept(
  function stats2d_intercept (line 1264) | fn stats2d_intercept(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_x_intercept (line 1270) | pub fn arrow_stats2d_x_intercept(
  function stats2d_x_intercept (line 1278) | fn stats2d_x_intercept(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_determination_coeff (line 1284) | pub fn arrow_stats2d_determination_coeff(
  function stats2d_determination_coeff (line 1292) | fn stats2d_determination_coeff(summary: StatsSummary2D) -> Option<f64> {
  function arrow_stats2d_covar (line 1298) | pub fn arrow_stats2d_covar(sketch: Option<StatsSummary2D>, accessor: Acc...
  function stats2d_covar (line 1303) | fn stats2d_covar(
  type Method (line 1317) | pub enum Method {
    method as_str (line 1323) | pub fn as_str(&self) -> &'static str {
  function method_kind (line 1332) | pub fn method_kind(method: &str) -> Method {
  function as_method (line 1341) | pub fn as_method(method: &str) -> Option<Method> {
  constant RUNS (line 1404) | const RUNS: usize = 10;
  constant VALS (line 1405) | const VALS: usize = 10000;
  constant SEED (line 1406) | const SEED: Option<u64> = None;
  constant PRINT_VALS (line 1407) | const PRINT_VALS: bool = false;
  function test_stats_agg_text_io (line 1410) | fn test_stats_agg_text_io() {
  function test_stats_agg_byte_io (line 1583) | fn test_stats_agg_byte_io() {
  function stats_agg_fuzz (line 1612) | fn stats_agg_fuzz() {
  type TestState (line 1621) | struct TestState {
    method new (line 1632) | pub fn new(runs: usize, values: usize, seed: Option<u64>) -> TestState {
    method populate_values (line 1649) | pub fn populate_values(&mut self) {
    method failed_msg (line 1672) | pub fn failed_msg(&self, dump_vals: bool) -> String {
  function check_agg_equivalence (line 1684) | fn check_agg_equivalence(
  function pg1d_aggx (line 1746) | fn pg1d_aggx(agg: &str) -> String {
  function pg1d_aggy (line 1750) | fn pg1d_aggy(agg: &str) -> String {
  function pg2d_agg (line 1754) | fn pg2d_agg(agg: &str) -> String {
  function tk1d_agg (line 1758) | fn tk1d_agg(agg: &str) -> String {
  function tk1d_agg_arg (line 1768) | fn tk1d_agg_arg(agg: &str, arg: &str) -> String {
  function tk2d_agg (line 1778) | fn tk2d_agg(agg: &str) -> String {
  function tk2d_agg_arg (line 1788) | fn tk2d_agg_arg(agg: &str, arg: &str) -> String {
  function pg_moment_pop_query (line 1798) | fn pg_moment_pop_query(moment: i32, column: &str) -> String {
  function pg_moment_samp_query (line 1802) | fn pg_moment_samp_query(moment: i32, column: &str) -> String {
  function test_aggs (line 1806) | fn test_aggs(state: &mut TestState) {
  function stats_agg_rolling (line 2221) | fn stats_agg_rolling() {

FILE: extension/src/tdigest.rs
  function tdigest_trans (line 21) | pub fn tdigest_trans(
  function tdigest_trans_inner (line 29) | pub fn tdigest_trans_inner(
  function tdigest_combine (line 60) | pub fn tdigest_combine(
  function tdigest_combine_inner (line 68) | pub fn tdigest_combine_inner(
  function tdigest_serialize (line 90) | pub fn tdigest_serialize(state: Internal) -> bytea {
  function tdigest_deserialize (line 100) | pub fn tdigest_deserialize(bytes: bytea, _internal: Internal) -> Option<...
  function tdigest_deserialize_inner (line 103) | pub fn tdigest_deserialize_inner(bytes: bytea) -> Inner<tdigest::Builder> {
  method output (line 124) | fn output(&self, buffer: &mut StringInfo) {
  method input (line 134) | fn input(input: &std::ffi::CStr) -> TDigest<'input>
  function to_internal_tdigest (line 152) | fn to_internal_tdigest(&self) -> InternalTDigest {
  function from_internal_tdigest (line 163) | fn from_internal_tdigest(digest: &InternalTDigest) -> TDigest<'static> {
  function tdigest_final (line 186) | fn tdigest_final(state: Internal, fcinfo: pg_sys::FunctionCallInfo) -> O...
  function tdigest_compound_trans (line 223) | pub fn tdigest_compound_trans(
  function tdigest_compound_trans_inner (line 230) | pub fn tdigest_compound_trans_inner(
  function tdigest_compound_combine (line 255) | pub fn tdigest_compound_combine(
  function tdigest_compound_combine_inner (line 264) | pub fn tdigest_compound_combine_inner(
  function tdigest_compound_final (line 290) | fn tdigest_compound_final(
  function tdigest_compound_serialize (line 299) | fn tdigest_compound_serialize(state: Internal, _fcinfo: pg_sys::Function...
  function tdigest_compound_deserialize (line 305) | pub fn tdigest_compound_deserialize(bytes: bytea, _internal: Internal) -...
  function arrow_tdigest_approx_percentile (line 338) | pub fn arrow_tdigest_approx_percentile<'a>(
  function tdigest_quantile (line 347) | pub fn tdigest_quantile<'a>(quantile: f64, digest: TDigest<'a>) -> f64 {
  function arrow_tdigest_approx_rank (line 353) | pub fn arrow_tdigest_approx_rank<'a>(
  function tdigest_quantile_at_value (line 362) | pub fn tdigest_quantile_at_value<'a>(value: f64, digest: TDigest<'a>) ->...
  function arrow_tdigest_num_vals (line 370) | pub fn arrow_tdigest_num_vals<'a>(sketch: TDigest<'a>, _accessor: Access...
  function tdigest_count (line 376) | pub fn tdigest_count<'a>(digest: TDigest<'a>) -> f64 {
  function arrow_tdigest_min (line 382) | pub fn arrow_tdigest_min<'a>(sketch: TDigest<'a>, _accessor: AccessorMin...
  function tdigest_min (line 388) | pub fn tdigest_min<'a>(digest: TDigest<'a>) -> f64 {
  function arrow_tdigest_max (line 394) | pub fn arrow_tdigest_max<'a>(sketch: TDigest<'a>, _accessor: AccessorMax...
  function tdigest_max (line 400) | pub fn tdigest_max<'a>(digest: TDigest<'a>) -> f64 {
  function arrow_tdigest_mean (line 406) | pub fn arrow_tdigest_mean<'a>(sketch: TDigest<'a>, _accessor: AccessorMe...
  function tdigest_mean (line 413) | pub fn tdigest_mean<'a>(digest: TDigest<'a>) -> f64 {
  function tdigest_sum (line 423) | pub fn tdigest_sum(digest: TDigest<'_>) -> f64 {
  function apx_eql (line 435) | fn apx_eql(value: f64, expected: f64, error: f64) {
  function pct_eql (line 443) | fn pct_eql(value: f64, expected: f64, pct_error: f64) {
  function test_tdigest_aggregate (line 448) | fn test_tdigest_aggregate() {
  function test_tdigest_small_count (line 583) | fn test_tdigest_small_count() {
  function serialization_matches (line 605) | fn serialization_matches() {
  function test_tdigest_io (line 618) | fn test_tdigest_io() {
  function test_tdigest_byte_io (line 652) | fn test_tdigest_byte_io() {
  function test_tdigest_compound_agg (line 684) | fn test_tdigest_compound_agg() {

FILE: extension/src/time_vector.rs
  constant FLAG_IS_SORTED (line 28) | pub const FLAG_IS_SORTED: u8 = 0x01;
  constant FLAG_HAS_NULLS (line 29) | pub const FLAG_HAS_NULLS: u8 = 0x01 << 1;
  function num_points (line 46) | pub fn num_points(&self) -> usize {
  function get (line 52) | pub fn get(&self, index: usize) -> Option<TSPoint> {
  function is_sorted (line 61) | pub fn is_sorted(&self) -> bool {
  function has_nulls (line 66) | pub fn has_nulls(&self) -> bool {
  function is_null_val (line 70) | pub fn is_null_val(&self, index: usize) -> bool {
  function clone_owned (line 79) | fn clone_owned(&self) -> Timevector_TSTZ_F64<'static> {
  function iter (line 85) | pub fn iter(&self) -> Iter<'_> {
  function num_vals (line 91) | pub fn num_vals(&self) -> usize {
  type Item (line 97) | type Item = TSPoint;
  type IntoIter (line 98) | type IntoIter = Iter<'a>;
  method into_iter (line 100) | fn into_iter(self) -> Self::IntoIter {
  function unnest (line 112) | pub fn unnest<'a>(
  function timestamptz_to_string (line 124) | pub fn timestamptz_to_string(time: pg_sys::TimestampTz) -> Result<String...
  function to_plotly (line 131) | pub fn to_plotly<'a>(series: Timevector_TSTZ_F64<'a>) -> String {
  function to_text (line 136) | pub fn to_text<'a>(series: Timevector_TSTZ_F64<'a>, format_string: Strin...
  function format_timevector (line 140) | pub fn format_timevector<'a>(series: Timevector_TSTZ_F64<'a>, format_str...
  function arrow_timevector_unnest (line 183) | pub fn arrow_timevector_unnest<'a>(
  function timevector_serialize (line 191) | pub fn timevector_serialize(state: Internal) -> bytea {
  function timevector_deserialize (line 198) | pub fn timevector_deserialize(bytes: bytea, _internal: Internal) -> Opti...
  function timevector_tstz_f64_trans (line 204) | pub fn timevector_tstz_f64_trans(
  function timevector_trans_inner (line 213) | pub fn timevector_trans_inner(
  function timevector_tstz_f64_compound_trans (line 264) | pub fn timevector_tstz_f64_compound_trans<'a>(
  function inner_compound_trans (line 272) | pub fn inner_compound_trans<'b>(
  function timevector_combine (line 291) | pub fn timevector_combine(
  function inner_combine (line 299) | pub fn inner_combine<'a, 'b>(
  function combine (line 314) | pub fn combine(
  function timevector_final (line 366) | pub fn timevector_final(
  function timevector_final_inner (line 373) | pub fn timevector_final_inner<'a>(
  function asof_join (line 439) | pub fn asof_join<'a, 'b>(
  function accessor_asof (line 496) | pub fn accessor_asof<'a>(tv: Timevector_TSTZ_F64<'a>) -> AccessorAsof<'s...
  function arrow_timevector_asof (line 509) | pub fn arrow_timevector_asof<'a>(
  function test_unnest (line 530) | pub fn test_unnest() {
  function test_format_timevector (line 586) | pub fn test_format_timevector() {
  function test_format_timevector_panics_on_infinities (line 665) | pub fn test_format_timevector_panics_on_infinities() {
  function timevector_io (line 707) | pub fn timevector_io() {
  function test_arrow_equivalence (line 774) | pub fn test_arrow_equivalence() {
  function test_rollup (line 825) | pub fn test_rollup() {
  function test_rollup_preserves_nulls_flag (line 902) | fn test_rollup_preserves_nulls_flag() {
  function test_asof_join (line 960) | fn test_asof_join() {
  function test_asof_none (line 1004) | fn test_asof_none() {
  function test_none_asof (line 1024) | fn test_none_asof() {

FILE: extension/src/time_vector/iter.rs
  type Iter (line 5) | pub enum Iter<'a> {
  type Item (line 12) | type Item = TSPoint;
  method next (line 14) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 24) | fn size_hint(&self) -> (usize, Option<usize>) {
  method count (line 30) | fn count(self) -> usize

FILE: extension/src/time_vector/pipeline.rs
  function flatten (line 83) | pub fn flatten<'a>(self) -> UnstableTimevectorPipeline<'a> {
  function from (line 100) | fn from(element: Element<'e>) -> Self {
  function arrow_run_pipeline (line 115) | pub fn arrow_run_pipeline<'a>(
  function run_pipeline_elements (line 122) | pub fn run_pipeline_elements<'s, 'j, 'i>(
  function execute_pipeline_element (line 132) | pub fn execute_pipeline_element<'s>(
  function arrow_add_unstable_element (line 152) | pub fn arrow_add_unstable_element<'p>(
  function pipeline_support (line 167) | pub unsafe fn pipeline_support(input: Internal) -> Internal {
  function pipeline_support_helper (line 181) | pub(crate) unsafe fn pipeline_support_helper(
  function no_change (line 283) | fn no_change() -> pgrx::Internal {
  function lttb_pipeline_element (line 308) | pub fn lttb_pipeline_element(
  function test_pipeline_lttb (line 324) | fn test_pipeline_lttb() {
  function test_pipeline_folding (line 467) | fn test_pipeline_folding() {

FILE: extension/src/time_vector/pipeline/aggregation.rs
  function arrow_run_pipeline_then_stats_agg (line 106) | pub fn arrow_run_pipeline_then_stats_agg<'a>(
  function finalize_with_stats_agg (line 122) | pub fn finalize_with_stats_agg<'e>(
  function pipeline_stats_agg (line 154) | pub fn pipeline_stats_agg() -> toolkit_experimental::PipelineThenStatsAg...
  function pipeline_stats_agg_support (line 164) | pub unsafe fn pipeline_stats_agg_support(input: Internal) -> Internal {
  function sum_pipeline_element (line 192) | pub fn sum_pipeline_element<'a>(
  function arrow_pipeline_then_sum (line 216) | pub fn arrow_pipeline_then_sum<'a>(
  function finalize_with_sum (line 233) | pub fn finalize_with_sum<'e>(
  function pipeline_sum_support (line 260) | pub unsafe fn pipeline_sum_support(input: Internal) -> Internal {
  function average_pipeline_element (line 280) | pub fn average_pipeline_element(
  function arrow_pipeline_then_average (line 308) | pub fn arrow_pipeline_then_average<'a>(
  function finalize_with_average (line 325) | pub fn finalize_with_average<'e>(
  function pipeline_average_support (line 352) | pub unsafe fn pipeline_average_support(input: Internal) -> Internal {
  function num_vals_pipeline_element (line 377) | pub fn num_vals_pipeline_element(
  function arrow_pipeline_then_num_vals (line 405) | pub fn arrow_pipeline_then_num_vals<'a>(
  function finalize_with_num_vals (line 414) | pub fn finalize_with_num_vals<'e>(
  function pipeline_num_vals_support (line 441) | pub unsafe fn pipeline_num_vals_support(input: Internal) -> Internal {
  function arrow_run_pipeline_then_counter_agg (line 463) | pub fn arrow_run_pipeline_then_counter_agg<'a>(
  function finalize_with_counter_agg (line 484) | pub fn finalize_with_counter_agg<'e>(
  function pipeline_counter_agg (line 516) | pub fn pipeline_counter_agg() -> toolkit_experimental::PipelineThenCount...
  function pipeline_counter_agg_support (line 526) | pub unsafe fn pipeline_counter_agg_support(input: Internal) -> Internal {
  function arrow_run_pipeline_then_hyperloglog (line 553) | pub fn arrow_run_pipeline_then_hyperloglog<'a>(
  function finalize_with_hyperloglog (line 569) | pub fn finalize_with_hyperloglog<'e>(
  function pipeline_hyperloglog (line 603) | pub fn pipeline_hyperloglog(size: i32) -> toolkit_experimental::Pipeline...
  function pipeline_hyperloglog_support (line 614) | pub unsafe fn pipeline_hyperloglog_support(input: Internal) -> Internal {
  function arrow_run_pipeline_then_percentile_agg (line 641) | pub fn arrow_run_pipeline_then_percentile_agg<'a>(
  function finalize_with_percentile_agg (line 650) | pub fn finalize_with_percentile_agg<'e>(
  function pipeline_percentile_agg (line 682) | pub fn pipeline_percentile_agg() -> toolkit_experimental::PipelineThenPe...
  function pipeline_percentile_agg_support (line 692) | pub unsafe fn pipeline_percentile_agg_support(input: Internal) -> Intern...
  function test_stats_agg_finalizer (line 724) | fn test_stats_agg_finalizer() {
  function test_stats_agg_pipeline_folding (line 770) | fn test_stats_agg_pipeline_folding() {
  function test_sum_finalizer (line 820) | fn test_sum_finalizer() {
  function test_sum_pipeline_folding (line 863) | fn test_sum_pipeline_folding() {
  function test_average_finalizer (line 913) | fn test_average_finalizer() {
  function test_average_pipeline_folding (line 956) | fn test_average_pipeline_folding() {
  function test_num_vals_finalizer (line 1006) | fn test_num_vals_finalizer() {
  function test_num_vals_pipeline_folding (line 1049) | fn test_num_vals_pipeline_folding() {
  function test_counter_agg_finalizer (line 1099) | fn test_counter_agg_finalizer() {
  function test_hyperloglog_finalizer (line 1180) | fn test_hyperloglog_finalizer() {
  function test_percentile_agg_finalizer (line 1270) | fn test_percentile_agg_finalizer() {
  function test_percentile_agg_pipeline_folding (line 1330) | fn test_percentile_agg_pipeline_folding() {

FILE: extension/src/time_vector/pipeline/arithmetic.rs
  type Function (line 14) | pub enum Function {
  function apply (line 36) | pub fn apply(
  function pipeline_add (line 76) | pub fn pipeline_add(rhs: f64) -> toolkit_experimental::UnstableTimevecto...
  function pipeline_sub (line 86) | pub fn pipeline_sub(rhs: f64) -> toolkit_experimental::UnstableTimevecto...
  function pipeline_mul (line 96) | pub fn pipeline_mul(rhs: f64) -> toolkit_experimental::UnstableTimevecto...
  function pipeline_div (line 106) | pub fn pipeline_div(rhs: f64) -> toolkit_experimental::UnstableTimevecto...
  function pipeline_mod (line 116) | pub fn pipeline_mod(rhs: f64) -> toolkit_experimental::UnstableTimevecto...
  function pipeline_power (line 126) | pub fn pipeline_power(rhs: f64) -> toolkit_experimental::UnstableTimevec...
  function pipeline_log_n (line 141) | pub fn pipeline_log_n(rhs: f64) -> toolkit_experimental::UnstableTimevec...
  function pipeline_abs (line 159) | pub fn pipeline_abs() -> toolkit_experimental::UnstableTimevectorPipelin...
  function pipeline_cbrt (line 173) | pub fn pipeline_cbrt() -> toolkit_experimental::UnstableTimevectorPipeli...
  function pipeline_ceil (line 187) | pub fn pipeline_ceil() -> toolkit_experimental::UnstableTimevectorPipeli...
  function pipeline_floor (line 201) | pub fn pipeline_floor() -> toolkit_experimental::UnstableTimevectorPipel...
  function pipeline_ln (line 210) | pub fn pipeline_ln() -> toolkit_experimental::UnstableTimevectorPipeline...
  function pipeline_log10 (line 224) | pub fn pipeline_log10() -> toolkit_experimental::UnstableTimevectorPipel...
  function pipeline_round (line 238) | pub fn pipeline_round() -> toolkit_experimental::UnstableTimevectorPipel...
  function pipeline_sign (line 252) | pub fn pipeline_sign() -> toolkit_experimental::UnstableTimevectorPipeli...
  function pipeline_sqrt (line 266) | pub fn pipeline_sqrt() -> toolkit_experimental::UnstableTimevectorPipeli...
  function pipeline_trunc (line 280) | pub fn pipeline_trunc() -> toolkit_experimental::UnstableTimevectorPipel...
  function test_simple_arith_binops (line 295) | fn test_simple_arith_binops() {
  function test_simple_arith_unaryops (line 473) | fn test_simple_arith_unaryops() {

FILE: extension/src/time_vector/pipeline/delta.rs
  function delta_pipeline_element (line 14) | pub fn delta_pipeline_element(
  function timevector_delta (line 31) | pub fn timevector_delta<'s>(series: &Timevector_TSTZ_F64<'s>) -> Timevec...
  function test_pipeline_delta (line 69) | fn test_pipeline_delta() {

FILE: extension/src/time_vector/pipeline/expansion.rs
  function pipeline_unnest (line 45) | pub fn pipeline_unnest() -> toolkit_experimental::PipelineThenUnnest<'st...
  function arrow_finalize_with_unnest (line 56) | pub fn arrow_finalize_with_unnest<'p>(
  function arrow_run_pipeline_then_unnest (line 84) | pub fn arrow_run_pipeline_then_unnest<'a>(
  function pipeline_series (line 100) | pub fn pipeline_series() -> toolkit_experimental::PipelineForceMateriali...
  function arrow_force_materialize (line 111) | pub fn arrow_force_materialize<'e>(
  function arrow_run_pipeline_then_materialize (line 139) | pub fn arrow_run_pipeline_then_materialize<'a>(
  function pipeline_materialize_support (line 147) | pub unsafe fn pipeline_materialize_support(input: pgrx::Internal) -> pgr...
  function test_unnest_finalizer (line 176) | fn test_unnest_finalizer() {
  function test_series_finalizer (line 222) | fn test_series_finalizer() {
  function test_force_materialize (line 274) | fn test_force_materialize() {

FILE: extension/src/time_vector/pipeline/fill_to.rs
  type FillToMethod (line 12) | pub enum FillToMethod {
    method fill_point (line 19) | pub fn fill_point(&self, lhs: &TSPoint, rhs: &TSPoint, target_ts: i64)...
  function fillto_pipeline_element (line 58) | pub fn fillto_pipeline_element(
  function fill_to (line 85) | pub fn fill_to<'s>(
  function test_pipeline_fill_to (line 148) | fn test_pipeline_fill_to() {

FILE: extension/src/time_vector/pipeline/filter.rs
  function filter_lambda_pipeline_element (line 12) | pub fn filter_lambda_pipeline_element<'l>(
  function apply_lambda_to (line 26) | pub fn apply_lambda_to<'a>(
  function filter_lambda_over_series (line 51) | pub fn filter_lambda_over_series(
  function test_pipeline_filter_lambda (line 66) | fn test_pipeline_filter_lambda() {

FILE: extension/src/time_vector/pipeline/lambda.rs
  method output (line 35) | fn output(&self, buffer: &mut StringInfo) {
  method input (line 45) | fn input(input: &std::ffi::CStr) -> Self
  function parse (line 66) | pub fn parse(&self) -> Expression {
  function bool_lambda (line 76) | pub fn bool_lambda<'a>(
  function f64_lambda (line 90) | pub fn f64_lambda<'a>(
  function ttz_lambda (line 104) | pub fn ttz_lambda<'a>(
  function interval_lambda (line 119) | pub fn interval_lambda<'a>(
  function point_lambda (line 133) | pub fn point_lambda<'a>(
  function trace_lambda (line 152) | pub fn trace_lambda<'a>(
  type Expression (line 180) | pub struct Expression {
    method ty (line 272) | pub fn ty(&self) -> &Type {
    method ty_is_ts_point (line 276) | pub fn ty_is_ts_point(&self) -> bool {
  type ExpressionSegment (line 186) | pub enum ExpressionSegment {
    method ty (line 282) | pub fn ty(&self) -> &Type {
    method ty_is_ts_point (line 299) | pub fn ty_is_ts_point(&self) -> bool {
    method name (line 308) | pub fn name(&self) -> Cow<'static, str> {
  type UnaryOp (line 200) | pub enum UnaryOp {
  type BinOp (line 206) | pub enum BinOp {
  type Function (line 223) | pub enum Function {
  type Type (line 253) | pub enum Type {
  type Value (line 263) | pub enum Value {
    method bool (line 326) | pub(crate) fn bool(&self) -> bool {
    method float (line 333) | pub(crate) fn float(&self) -> f64 {
    method time (line 340) | pub(crate) fn time(&self) -> i64 {
    method interval (line 347) | pub(crate) fn interval(&self) -> *mut pg_sys::Interval {
    method from (line 428) | fn from(b: bool) -> Self {
    method from (line 434) | fn from(f: f64) -> Self {
  method partial_cmp (line 356) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
  method eq (line 397) | fn eq(&self, other: &Self) -> bool {
  function into_data (line 440) | pub fn into_data(self) -> LambdaData<'a> {
  function test_lambda_general (line 562) | fn test_lambda_general() {
  function test_lambda_comparison (line 728) | fn test_lambda_comparison() {
  function test_lambda_function (line 780) | fn test_lambda_function() {
  function test_lambda_unary (line 831) | fn test_lambda_unary() {
  function test_lambda_interval_ops (line 864) | fn test_lambda_interval_ops() {
  function test_lambda_variable (line 895) | fn test_lambda_variable() {

FILE: extension/src/time_vector/pipeline/lambda/executor.rs
  type ExpressionExecutor (line 5) | pub struct ExpressionExecutor<'e, T> {
  function new (line 12) | pub fn new(exprs: &'e Expression) -> Self {
  function with_fn_tracer (line 21) | pub fn with_fn_tracer(exprs: &'e Expression, tracer: T) -> Self
  function with_tracer (line 28) | pub fn with_tracer(exprs: &'e Expression, tracer: T) -> Self {
  function reset (line 36) | pub fn reset(&mut self) {
  function exec (line 42) | pub fn exec(&mut self, value: f64, time: i64) -> Value {
  function exec_expression (line 46) | fn exec_expression(
  function force_var (line 80) | fn force_var(&mut self, i: usize, value: f64, time: i64) -> Value {
  function exec_function (line 90) | fn exec_function(
  function exec_unary_op (line 145) | fn exec_unary_op(
  function exec_binary_op (line 173) | fn exec_binary_op(
  type Tracer (line 361) | pub trait Tracer {
    method trace (line 362) | fn trace(&mut self, expr: &ExpressionSegment, result: &Value);
    method trace (line 366) | fn trace(&mut self, _: &ExpressionSegment, _: &Value) {}
    method trace (line 373) | fn trace(&mut self, expr: &ExpressionSegment, result: &Value) {

FILE: extension/src/time_vector/pipeline/lambda/parser.rs
  type ExpressionParser (line 33) | pub struct ExpressionParser;
  function parse_expression (line 35) | pub fn parse_expression(input: &str) -> Expression {
  function build_expression (line 44) | fn build_expression<'a>(
  function parse_primary (line 64) | fn parse_primary<'a>(
  function build_binary_op (line 215) | fn build_binary_op(
  function parse_timestamptz (line 366) | fn parse_timestamptz(val: &str) -> i64 {
  function parse_interval (line 388) | fn parse_interval(val: &str) -> *mut pg_sys::Interval {

FILE: extension/src/time_vector/pipeline/map.rs
  function map_lambda_pipeline_element (line 19) | pub fn map_lambda_pipeline_element<'l>(
  function apply_lambda_to (line 33) | pub fn apply_lambda_to<'a>(
  function map_lambda_over_series (line 65) | pub fn map_lambda_over_series(
  function map_series_pipeline_element (line 89) | pub fn map_series_pipeline_element(
  function map_series_element (line 95) | pub fn map_series_element<'a>(function: crate::raw::regproc) -> Element<...
  function check_user_function_type (line 105) | pub fn check_user_function_type(function: pg_sys::regproc) {
  function apply_to_series (line 124) | pub fn apply_to_series(
  function map_data_pipeline_element (line 154) | pub fn map_data_pipeline_element(
  function apply_to (line 185) | pub fn apply_to(
  function map_series (line 230) | pub fn map_series(series: &mut Timevector_TSTZ_F64<'_>, mut func: impl F...
  function test_pipeline_map_lambda (line 256) | fn test_pipeline_map_lambda() {
  function test_pipeline_map_lambda2 (line 339) | fn test_pipeline_map_lambda2() {
  function test_pipeline_map_data (line 439) | fn test_pipeline_map_data() {
  function test_pipeline_map_series (line 531) | fn test_pipeline_map_series() {
  function test_pipeline_map_series_failure (line 624) | fn test_pipeline_map_series_failure() {
  function test_pipeline_map_series_null (line 682) | fn test_pipeline_map_series_null() {
  function test_map_io (line 738) | fn test_map_io() {

FILE: extension/src/time_vector/pipeline/sort.rs
  function sort_pipeline_element (line 12) | pub fn sort_pipeline_element<'p>() -> toolkit_experimental::UnstableTime...
  function sort_timevector (line 16) | pub fn sort_timevector(mut series: Timevector_TSTZ_F64<'_>) -> Timevecto...
  function test_pipeline_sort (line 67) | fn test_pipeline_sort() {

FILE: extension/src/time_weighted_average.rs
  method internal (line 42) | fn internal(&self) -> TimeWeightSummaryInternal {
  method interpolate (line 51) | pub(super) fn interpolate(
  type TimeWeightTransState (line 115) | pub struct TimeWeightTransState {
    method push_point (line 123) | fn push_point(&mut self, value: TSPoint) {
    method combine_points (line 127) | fn combine_points(&mut self) {
    method push_summary (line 139) | fn push_summary(&mut self, other: &TimeWeightTransState) {
    method combine_summaries (line 146) | fn combine_summaries(&mut self) {
  function time_weight_trans_serialize (line 158) | pub fn time_weight_trans_serialize(state: Internal) -> bytea {
  function time_weight_trans_deserialize (line 165) | pub fn time_weight_trans_deserialize(bytes: bytea, _internal: Internal) ...
  function time_weight_trans_deserialize_inner (line 168) | pub fn time_weight_trans_deserialize_inner(bytes: bytea) -> Inner<TimeWe...
  function time_weight_trans (line 175) | pub fn time_weight_trans(
  function time_weight_trans_inner (line 185) | pub fn time_weight_trans_inner(
  function time_weight_summary_trans (line 225) | pub fn time_weight_summary_trans(
  function time_weight_summary_trans_inner (line 233) | pub fn time_weight_summary_trans_inner(
  function time_weight_combine (line 264) | pub fn time_weight_combine(
  function time_weight_combine_inner (line 272) | pub fn time_weight_combine_inner(
  function time_weight_final (line 305) | fn time_weight_final(
  function time_weight_final_inner (line 312) | fn time_weight_final_inner(
  function arrow_time_weight_first_val (line 338) | pub fn arrow_time_weight_first_val(sketch: TimeWeightSummary, _accessor:...
  function time_weight_first_val (line 343) | fn time_weight_first_val(summary: TimeWeightSummary) -> f64 {
  function arrow_time_weight_last_val (line 349) | pub fn arrow_time_weight_last_val(sketch: TimeWeightSummary, _accessor: ...
  function time_weight_last_val (line 354) | fn time_weight_last_val(summary: TimeWeightSummary) -> f64 {
  function arrow_time_weight_first_time (line 360) | pub fn arrow_time_weight_first_time(
  function time_weight_first_time (line 368) | fn time_weight_first_time(summary: TimeWeightSummary) -> crate::raw::Tim...
  function arrow_time_weight_last_time (line 374) | pub fn arrow_time_weight_last_time(
  function time_weight_last_time (line 382) | fn time_weight_last_time(summary: TimeWeightSummary) -> crate::raw::Time...
  function arrow_time_weighted_average_average (line 423) | pub fn arrow_time_weighted_average_average(
  function arrow_time_weighted_average_integral (line 432) | pub fn arrow_time_weighted_average_integral(
  function time_weighted_average_average (line 443) | pub fn time_weighted_average_average(tws: Option<TimeWeightSummary>) -> ...
  function time_weighted_average_integral (line 461) | pub fn time_weighted_average_integral(
  function interpolate (line 476) | fn interpolate(
  function time_weighted_average_interpolated_average (line 493) | pub fn time_weighted_average_interpolated_average(
  function arrow_time_weighted_average_interpolated_average (line 506) | pub fn arrow_time_weighted_average_interpolated_average(
  function time_weighted_average_interpolated_integral (line 531) | pub fn time_weighted_average_interpolated_integral(
  function arrow_time_weighted_average_interpolated_integral (line 545) | pub fn arrow_time_weighted_average_interpolated_integral(
  function test_time_weight_aggregate (line 599) | fn test_time_weight_aggregate() {
  function test_time_weight_io (line 712) | fn test_time_weight_io() {
  function test_time_weight_byte_io (line 796) | fn test_time_weight_byte_io() {
  function test_time_weight_interpolation (line 866) | fn test_time_weight_interpolation() {
  function test_locf_interpolation_to_null (line 1004) | fn test_locf_interpolation_to_null() {

FILE: extension/src/time_weighted_average/accessors.rs
  function time_weight_interpolated_average_accessor (line 26) | fn time_weight_interpolated_average_accessor(
  function time_weight_interpolated_integral_accessor (line 75) | fn time_weight_interpolated_integral_accessor(

FILE: extension/src/type_builder.rs
  type CachedDatum (line 2) | pub enum CachedDatum<'r> {
  method eq (line 9) | fn eq(&self, _: &Self) -> bool {
  function deserialize (line 19) | fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
  type SerializationType (line 713) | pub enum SerializationType {

FILE: extension/src/uddsketch.rs
  function uddsketch_trans (line 21) | pub fn uddsketch_trans(
  function uddsketch_trans_inner (line 31) | pub fn uddsketch_trans_inner(
  constant PERCENTILE_AGG_DEFAULT_SIZE (line 55) | const PERCENTILE_AGG_DEFAULT_SIZE: u32 = 200;
  constant PERCENTILE_AGG_DEFAULT_ERROR (line 56) | const PERCENTILE_AGG_DEFAULT_ERROR: f64 = 0.001;
  function percentile_agg_trans (line 61) | pub fn percentile_agg_trans(
  function percentile_agg_trans_inner (line 69) | pub fn percentile_agg_trans_inner(
  function uddsketch_combine (line 80) | pub fn uddsketch_combine(
  function uddsketch_combine_inner (line 87) | pub fn uddsketch_combine_inner(
  function uddsketch_serialize (line 109) | pub fn uddsketch_serialize(state: Internal) -> bytea {
  function uddsketch_deserialize (line 115) | pub fn uddsketch_deserialize(bytes: bytea, _internal: Internal) -> Optio...
  function uddsketch_deserialize_inner (line 118) | pub fn uddsketch_deserialize_inner(bytes: bytea) -> Inner<UddSketchInter...
  type SerializedUddSketch (line 124) | struct SerializedUddSketch {
    method from (line 135) | fn from(sketch: &UddSketchInternal) -> Self {
    method keys (line 168) | fn keys(&self) -> impl Iterator<Item = SketchHashKey> + '_ {
    method counts (line 176) | fn counts(&self) -> impl Iterator<Item = u64> + '_ {
  method from (line 150) | fn from(sketch: SerializedUddSketch) -> Self {
  type ReadableUddSketch (line 208) | struct ReadableUddSketch {
    method from (line 220) | fn from(sketch: &UddSketch<'_>) -> Self {
  function from (line 235) | fn from(sketch: &'a ReadableUddSketch) -> Self {
  method output (line 271) | fn output(&self, buffer: &mut StringInfo) {
  method input (line 281) | fn input(input: &std::ffi::CStr) -> Self
  function keys (line 294) | fn keys(&self) -> impl Iterator<Item = SketchHashKey> + '_ {
  function counts (line 303) | fn counts(&self) -> impl Iterator<Item = u64> + '_ {
  function metadata (line 312) | fn metadata(&self) -> UDDSketchMetadata {
  function to_uddsketch (line 324) | fn to_uddsketch(&self) -> UddSketchInternal {
  function from_internal (line 328) | fn from_internal(state: &UddSketchInternal) -> Self {
  function from_iter (line 362) | fn from_iter<T: IntoIterator<Item = f64>>(iter: T) -> Self {
  function uddsketch_final (line 376) | fn uddsketch_final(
  function uddsketch_final_inner (line 382) | fn uddsketch_final_inner(
  type CompressedBuckets (line 399) | struct CompressedBuckets {
  function compress_buckets (line 407) | fn compress_buckets(buckets: impl Iterator<Item = (SketchHashKey, u64)>)...
  function decompress_keys (line 440) | fn de

[
  {
    "path": ".cargo/config",
    "chars": 122,
    "preview": "[build]\n# Postgres symbols won't ve available until runtime\nrustflags = [\"-C\", \"link-args=-Wl,-undefined,dynamic_lookup\""
  },
  {
    "path": ".dockerignore",
    "chars": 109,
    "preview": "**/*.iml\n**/*.o\n**/.DS_Store\n.editorconfig\n.idea\n.vscode\n.vsls.json\n.git\nold-versions\ntarget\ntarget-analyzer\n"
  },
  {
    "path": ".git-blame-ignore-revs",
    "chars": 130,
    "preview": "# Merge and parent commit for cargo fmt changes\nb7433344f90b142094e73e84c332385498db9335\n8b50127c9e4bad1696a68a800ce1ef0"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug-report.md",
    "chars": 945,
    "preview": "---\nname: Bug Report\nabout: Something is not working as expected\ntitle: ''\nlabels: bug\nassignees: ''\n\n---\n\n**Relevant sy"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature-request.md",
    "chars": 614,
    "preview": "---\nname: Feature Request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: feature-request\nassignees: ''\n\n---\n\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature-stabilization.md",
    "chars": 1102,
    "preview": "---\nname: Feature Stabilization\nabout: Checklist of tasks to move a feature out of experimental\ntitle: ''\nlabels: ''\nass"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/proposed-feature.md",
    "chars": 975,
    "preview": "---\nname: Proposed Feature\nabout: Propose a solution to a problem or wishlist item\ntitle: ''\nlabels: proposed-feature\nas"
  },
  {
    "path": ".github/workflows/add-to-bugs-board.yml",
    "chars": 2232,
    "preview": "name: Add bugs to bugs project\n\n\"on\":\n  issues:\n    types: [opened, labeled]\n  issue_comment:\n    types: [created, edite"
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 7715,
    "preview": "name: CI\non:\n  pull_request:\n  push:\n    branches:\n    - main\n    - staging\n    - trying\n  schedule:\n    # TimescaleDB i"
  },
  {
    "path": ".github/workflows/ci_image_build.yml",
    "chars": 1630,
    "preview": "name: Build CI Image\n\non:\n  pull_request:\n    paths:\n      - 'docker/ci/**'\n      - '.github/workflows/ci_image_build.ym"
  },
  {
    "path": ".github/workflows/clippy_rustfmt.yml",
    "chars": 1476,
    "preview": "name: Clippy and rustfmt\non:\n  pull_request:\n  push:\n    branches:\n    - main\n    - staging\n    - trying\n  workflow_disp"
  },
  {
    "path": ".github/workflows/dependency-updates.yml",
    "chars": 3059,
    "preview": "name: Dependency Updates\non:\n  schedule:\n    # Run on the 1st of every month at 9:00 AM UTC\n    - cron: '0 9 1 * *'\n  wo"
  },
  {
    "path": ".github/workflows/packaging.yml",
    "chars": 794,
    "preview": "# Trigger package workflows on release tagging\nname: Build packages\non:\n  push:\n    tags:\n    - \"[0-9]+.[0-9]+.[0-9]+\"\n "
  },
  {
    "path": ".github/workflows/release.yml",
    "chars": 1211,
    "preview": "name: Release\non:\n  workflow_dispatch:\n    inputs:\n      version:\n        description: 'New version number for release'\n"
  },
  {
    "path": ".github/workflows/report_packaging_failures.yml",
    "chars": 1440,
    "preview": "name: Report Build Package Failures\non:\n  workflow_run:\n    workflows: [Build packages, Build CI Image, CI]\n    types: ["
  },
  {
    "path": ".gitignore",
    "chars": 98,
    "preview": ".DS_Store\n/.idea\n/.vscode\n/.vsls.json\n/old-versions\n/target\n*.iml\n/target-analyzer\n/.editorconfig\n"
  },
  {
    "path": "Cargo.toml",
    "chars": 228,
    "preview": "[workspace]\nresolver = \"2\"\n\nmembers = [\n    \"crates/t-digest-lib\",\n    \"extension\",\n    \"tools/post-install\",\n    \"tools"
  },
  {
    "path": "Changelog.md",
    "chars": 35315,
    "preview": "# Toolkit Changelog\n\n## Process for updating this changelog\n\nThis changelog should be updated as part of a PR if the wor"
  },
  {
    "path": "LICENSE",
    "chars": 361,
    "preview": "Unless otherwise Source code in this repository, and any binaries built from\nthis source code, in whole or in part, are "
  },
  {
    "path": "NOTICE",
    "chars": 458,
    "preview": "TimescaleDB-Toolkit (TM)\n\nCopyright (c) 2021-2024  Timescale, Inc. All Rights Reserved.\n\nUnless otherwise stated, source"
  },
  {
    "path": "Readme.md",
    "chars": 4726,
    "preview": "[![CI](https://github.com/timescale/timescaledb-toolkit/actions/workflows/ci.yml/badge.svg?branch=main)](https://github."
  },
  {
    "path": "crates/aggregate_builder/Cargo.toml",
    "chars": 259,
    "preview": "[package]\nname = \"aggregate_builder\"\nversion = \"0.1.0\"\nedition = \"2018\"\n\n[lib]\nproc-macro = true\n\n[dependencies]\nsyn = {"
  },
  {
    "path": "crates/aggregate_builder/Readme.md",
    "chars": 10111,
    "preview": "# Aggregate Builder #\n\nLibrary for building Postgres [aggregate functions](https://www.postgresql.org/docs/current/xaggr"
  },
  {
    "path": "crates/aggregate_builder/src/lib.rs",
    "chars": 35023,
    "preview": "use std::borrow::Cow;\n\nuse proc_macro::TokenStream;\n\nuse proc_macro2::{Span, TokenStream as TokenStream2};\n\nuse quote::{"
  },
  {
    "path": "crates/asap/Cargo.toml",
    "chars": 75,
    "preview": "[package]\nname = \"asap\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\n"
  },
  {
    "path": "crates/asap/src/fft.rs",
    "chars": 7715,
    "preview": "// based on https://github.com/stanford-futuredata/ASAP/blob/8b39db4bc92590cbe5b44ddace9b7bb1d677248b/ASAP-optimized.js\n"
  },
  {
    "path": "crates/asap/src/lib.rs",
    "chars": 25079,
    "preview": "// based on https://github.com/stanford-futuredata/ASAP/blob/8b39db4bc92590cbe5b44ddace9b7bb1d677248b/ASAP-optimized.js\n"
  },
  {
    "path": "crates/count-min-sketch/Cargo.toml",
    "chars": 150,
    "preview": "[package]\nname = \"countminsketch\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nrand = \"0.8.4\"\nserde = { version = "
  },
  {
    "path": "crates/count-min-sketch/src/lib.rs",
    "chars": 8652,
    "preview": "//! Count-Min Sketch implementation in Rust\n//!\n//! Based on the paper:\n//! <http://dimacs.rutgers.edu/~graham/pubs/pape"
  },
  {
    "path": "crates/count-min-sketch/tests/lib.rs",
    "chars": 1510,
    "preview": "use countminsketch::CountMinSketch;\n\n#[test]\nfn empty_sketch() {\n    let cms = CountMinSketch::with_dim(1, 1);\n    asser"
  },
  {
    "path": "crates/counter-agg/Cargo.toml",
    "chars": 461,
    "preview": "[package]\nname = \"counter-agg\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc."
  },
  {
    "path": "crates/counter-agg/src/lib.rs",
    "chars": 14769,
    "preview": "use serde::{Deserialize, Serialize};\nuse stats_agg::{stats2d::StatsSummary2D, XYPair};\nuse std::fmt;\nuse tspoint::TSPoin"
  },
  {
    "path": "crates/counter-agg/src/range.rs",
    "chars": 8930,
    "preview": "use serde::{Deserialize, Serialize};\nuse std::cmp::{max, min};\n\n// we always store ranges as half open, inclusive on lef"
  },
  {
    "path": "crates/counter-agg/src/tests.rs",
    "chars": 21169,
    "preview": "// TODO Move to ../tests/lib.rs\n\nuse crate::range::I64Range;\nuse crate::*;\nuse approx::assert_relative_eq;\nfn to_micro(t"
  },
  {
    "path": "crates/encodings/Cargo.toml",
    "chars": 140,
    "preview": "[package]\nname = \"encodings\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\n\n[dev-dependencies]\nquickcheck = \"1\"\nqui"
  },
  {
    "path": "crates/encodings/src/lib.rs",
    "chars": 9118,
    "preview": "pub mod delta {\n    use crate::zigzag;\n\n    pub fn i64_decoder() -> impl FnMut(i64) -> i64 {\n        let mut prev = 0i64"
  },
  {
    "path": "crates/flat_serialize/Readme.md",
    "chars": 3184,
    "preview": "# Flat Serialize #\n\nA cannonicalization of write-to-pointer style serialization. You write a\ndefinition describing the l"
  },
  {
    "path": "crates/flat_serialize/example_generated.rs",
    "chars": 82731,
    "preview": "#![allow(unused_imports)]\nuse crate as flat_serialize;\n#[derive(Clone, Debug)]\npub struct Basic<'input> {\n    pub header"
  },
  {
    "path": "crates/flat_serialize/flat_serialize/Cargo.toml",
    "chars": 228,
    "preview": "[package]\nname = \"flat_serialize\"\nversion = \"0.1.0\"\nauthors = [\"Joshua Lockerman\"]\nedition = \"2021\"\n\n[dependencies]\norde"
  },
  {
    "path": "crates/flat_serialize/flat_serialize/src/lib.rs",
    "chars": 54207,
    "preview": "use std::{\n    fmt,\n    marker::PhantomData,\n    mem::{align_of, size_of, MaybeUninit},\n    slice,\n};\n#[derive(Debug)]\np"
  },
  {
    "path": "crates/flat_serialize/flat_serialize_macro/Cargo.toml",
    "chars": 306,
    "preview": "[package]\nname = \"flat_serialize_macro\"\nversion = \"0.1.0\"\nauthors = [\"Joshua Lockerman\"]\nedition = \"2021\"\n\n[lib]\nproc-ma"
  },
  {
    "path": "crates/flat_serialize/flat_serialize_macro/src/lib.rs",
    "chars": 53972,
    "preview": "use proc_macro::TokenStream;\n\nuse proc_macro2::TokenStream as TokenStream2;\n\nuse quote::{quote, quote_spanned};\n\nuse syn"
  },
  {
    "path": "crates/flat_serialize/flat_serialize_macro/src/parser.rs",
    "chars": 13755,
    "preview": "use std::{collections::HashSet, ops::Deref};\n\nuse proc_macro2::TokenStream as TokenStream2;\n\nuse syn::{\n    braced,\n    "
  },
  {
    "path": "crates/hyperloglogplusplus/Cargo.toml",
    "chars": 293,
    "preview": "[package]\nname = \"hyperloglogplusplus\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nserde = { version = \"1.0\", fea"
  },
  {
    "path": "crates/hyperloglogplusplus/src/dense.rs",
    "chars": 15929,
    "preview": "use crate::hyperloglog_data::{\n    BIAS_DATA_OFFSET, BIAS_DATA_VEC, RAW_ESTIMATE_DATA_OFFSET, RAW_ESTIMATE_DATA_VEC,\n   "
  },
  {
    "path": "crates/hyperloglogplusplus/src/hyperloglog_data.rs",
    "chars": 104216,
    "preview": "// based on https://github.com/crepererum/pdatastructs.rs/blob/e4f49e6462187700b9a12e8301df9a72a0c6e58c/src/hyperloglog_"
  },
  {
    "path": "crates/hyperloglogplusplus/src/lib.rs",
    "chars": 12423,
    "preview": "#[cfg(test)]\nextern crate quickcheck;\n#[cfg(test)]\n#[macro_use(quickcheck)]\nextern crate quickcheck_macros;\n\nuse std::{\n"
  },
  {
    "path": "crates/hyperloglogplusplus/src/registers.rs",
    "chars": 10601,
    "preview": "use std::{borrow::Cow, convert::TryInto, debug_assert};\n\n/// array of 6bit registers, of power-of-2 size\n// 24 is the LC"
  },
  {
    "path": "crates/hyperloglogplusplus/src/sparse/varint.rs",
    "chars": 3467,
    "preview": "use std::borrow::Cow;\n\nuse encodings::{delta, prefix_varint};\n\nuse super::Encoded;\n\npub fn decompression_iter<'a>(\n    C"
  },
  {
    "path": "crates/hyperloglogplusplus/src/sparse.rs",
    "chars": 12412,
    "preview": "use std::{\n    cmp::{\n        min,\n        Ordering::{Equal, Greater, Less},\n    },\n    collections::HashSet,\n};\n\nuse cr"
  },
  {
    "path": "crates/scripting-utilities/Readme.md",
    "chars": 621,
    "preview": "# Scripting Utilities #\n\nSmall helper crates for writing scripty code, such as found in tools.\nContains code that's _jus"
  },
  {
    "path": "crates/scripting-utilities/control_file_reader/Cargo.toml",
    "chars": 188,
    "preview": "[package]\nname = \"control_file_reader\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at http"
  },
  {
    "path": "crates/scripting-utilities/control_file_reader/src/lib.rs",
    "chars": 2100,
    "preview": "/// Code to extract info from `timescaledb_toolkit.control`\n/// This crate exists so we have a single source of truth fo"
  },
  {
    "path": "crates/scripting-utilities/postgres_connection_configuration/Cargo.toml",
    "chars": 202,
    "preview": "[package]\nname = \"postgres_connection_configuration\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their defin"
  },
  {
    "path": "crates/scripting-utilities/postgres_connection_configuration/src/lib.rs",
    "chars": 1637,
    "preview": "/// Config utility for connecting to multiple DBs in the same cluster\n// JOSH - I'm not sure if this really warrants a c"
  },
  {
    "path": "crates/stats-agg/Cargo.toml",
    "chars": 520,
    "preview": "[package]\nname = \"stats_agg\"\nversion = \"0.1.0\"\nauthors = [\"davidkohn88 <david@timescale.com>\"]\nedition = \"2021\"\n\n# See m"
  },
  {
    "path": "crates/stats-agg/src/lib.rs",
    "chars": 8336,
    "preview": "// stats is a small statistical regression lib that implements the Youngs-Cramer algorithm and is based on the Postgres "
  },
  {
    "path": "crates/stats-agg/src/stats1d.rs",
    "chars": 18790,
    "preview": "use crate::{m3, m4, FloatLike, StatsError, TwoFloat, INV_FLOATING_ERROR_THRESHOLD};\nuse serde::{Deserialize, Serialize};"
  },
  {
    "path": "crates/stats-agg/src/stats2d/stats2d_flat_serialize.rs",
    "chars": 16503,
    "preview": "use super::*;\n\n// expanded from FlatSerializable derive macro and made to work right with generic arg\n#[allow(warnings, "
  },
  {
    "path": "crates/stats-agg/src/stats2d.rs",
    "chars": 33929,
    "preview": "// 2D stats are based on the Youngs-Cramer implementation in PG here:\n// https://github.com/postgres/postgres/blob/472e5"
  },
  {
    "path": "crates/t-digest/Cargo.toml",
    "chars": 437,
    "preview": "[package]\nname = \"tdigest\"\nversion = \"0.2.2\"\nedition = \"2021\"\n# based on: https://github.com/MnO2/t-digest\"\n\n[dependenci"
  },
  {
    "path": "crates/t-digest/src/lib.rs",
    "chars": 34363,
    "preview": "// Based on https://github.com/MnO2/t-digest/blob/master/src/lib.rs\n// as of commit 66d7c19d32c1547daa628f1d9f12178a686b"
  },
  {
    "path": "crates/t-digest-lib/Cargo.toml",
    "chars": 214,
    "preview": "[package]\nname = \"tdigest-lib\"\nversion = \"0.0.0\"\nedition = \"2021\"\n\n[lib]\nname = \"timescaledb_toolkit_tdigest\"\ncrate-type"
  },
  {
    "path": "crates/t-digest-lib/src/lib.rs",
    "chars": 1873,
    "preview": "// There is no safety here:  it's all in the hands of the caller, bless their heart.\n#![allow(clippy::missing_safety_doc"
  },
  {
    "path": "crates/time-weighted-average/Cargo.toml",
    "chars": 448,
    "preview": "[package]\nname = \"time_weighted_average\"\nversion = \"0.1.0\"\nauthors = [\"David Kohn <david@timescale.com>\"]\nedition = \"202"
  },
  {
    "path": "crates/time-weighted-average/src/lib.rs",
    "chars": 29748,
    "preview": "use serde::{Deserialize, Serialize};\nuse tspoint::TSPoint;\n\nuse flat_serialize_macro::FlatSerializable;\n\n#[derive(Clone,"
  },
  {
    "path": "crates/tspoint/Cargo.toml",
    "chars": 357,
    "preview": "[package]\nname = \"tspoint\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust"
  },
  {
    "path": "crates/tspoint/src/lib.rs",
    "chars": 6064,
    "preview": "use serde::{ser::SerializeStruct, Deserialize, Serialize};\n\nuse flat_serialize_macro::FlatSerializable;\n\nuse std::ffi::C"
  },
  {
    "path": "crates/udd-sketch/Cargo.toml",
    "chars": 362,
    "preview": "[package]\nname = \"uddsketch\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.ru"
  },
  {
    "path": "crates/udd-sketch/src/lib.rs",
    "chars": 33822,
    "preview": "//! UDDSketch implementation in rust.\n//! Based on the paper: https://arxiv.org/abs/2004.08604\n\nuse serde::{Deserialize,"
  },
  {
    "path": "docker/README.md",
    "chars": 2481,
    "preview": "# Docker images\n\nTo speed up builds, we are using a set of pre-build docker images and\nthe Docker files for that is pres"
  },
  {
    "path": "docker/ci/Dockerfile",
    "chars": 1009,
    "preview": "ARG ARCH\nARG OS_NAME\nARG OS_VERSION\n\n# Without DockerKit, this doesn't work, even though documentation suggests it shoul"
  },
  {
    "path": "docker/ci/setup.sh",
    "chars": 9031,
    "preview": "#!/bin/sh\n\n# TODO rename to tools/setup - this is useful even for developer setup (add Mac/brew support)\n\nset -ex\n\nif [ "
  },
  {
    "path": "docs/README.md",
    "chars": 3652,
    "preview": "# TimescaleDB Toolkit Documentation\n---\nThe TimescaleDB Toolkit project contains a number of utilities for working with "
  },
  {
    "path": "docs/asap.md",
    "chars": 6737,
    "preview": "# ASAP Smoothing [<sup><mark>experimental</mark></sup>](/docs/README.md#tag-notes)\n\n> [Description](#asap-description)<b"
  },
  {
    "path": "docs/client.md",
    "chars": 6095,
    "preview": "# Client-side aggregation [<sup><mark>experimental</mark></sup>](/docs/README.md#tag-notes)\n\n- Current status: prototype"
  },
  {
    "path": "docs/counter_agg.md",
    "chars": 40468,
    "preview": "# Counter Aggregates\n\n> [Description](#counter-agg-description)<br>\n> [Example Usage](#counter-agg-examples)<br>\n> [API]"
  },
  {
    "path": "docs/examples/tdigest.c",
    "chars": 2195,
    "preview": "// cc -o tdigest tdigest.c $CARGO_TARGET_DIR/$PROFILE/libtimescaledb_toolkit_tdigest.a -lm -lpthread -ldl\n\n// Sample pro"
  },
  {
    "path": "docs/examples/tdigest.py",
    "chars": 3152,
    "preview": "import ctypes\nimport os\n\n_cdll = ctypes.CDLL(os.path.join(\n    os.getenv('CARGO_TARGET_DIR', 'target'),\n    os.getenv('P"
  },
  {
    "path": "docs/gauge_agg.md",
    "chars": 2159,
    "preview": "# Gauge Aggregates [<sup><mark>experimental</mark></sup>](/docs/README.md#tag-notes)\n\nA gauge is a metric similar to a c"
  },
  {
    "path": "docs/hyperloglog.md",
    "chars": 5369,
    "preview": "# Hyperloglog\n\n> [Description](#hyperloglog-description)<br>\n> [Details](#hyperloglog-details)<br>\n> [API](#hyperloglog-"
  },
  {
    "path": "docs/lttb.md",
    "chars": 5009,
    "preview": "# Largest Triangle Three Buckets\n\n> [Description](#description)<br>\n> [Example](#example)<br>\n> [API](#api)\n\n## Descript"
  },
  {
    "path": "docs/ordered-aggregates.md",
    "chars": 6364,
    "preview": "# Implementing aggregates that require ordered inputs\n\nPostgreSQL has a couple different ways of dealing with aggregates"
  },
  {
    "path": "docs/percentile_approximation.md",
    "chars": 31882,
    "preview": "# Approximate Percentiles\n> [Why To Use Approximate Percentiles](#why-use)<br>\n> [API](#percentile-approx-api) <br>\n> [A"
  },
  {
    "path": "docs/release.md",
    "chars": 10342,
    "preview": "# Release and build procedures\n\nWe build the timescaledb_toolkit extension using Cargo, but we have many\nhigher-level ta"
  },
  {
    "path": "docs/rolling_average_api_working.md",
    "chars": 7024,
    "preview": "\n# Info dump on rolling average APIs #\n\nRolling averages are currently nasty to do with with timescaledb (user complaint"
  },
  {
    "path": "docs/state_agg.md",
    "chars": 19909,
    "preview": "# State Aggregation [<sup><mark>experimental</mark></sup>](/docs/README.md#tag-notes)\n\n# Test table\n\nExamples below are "
  },
  {
    "path": "docs/stats_agg.md",
    "chars": 3239,
    "preview": "# Statistical Aggregates\n\n## Common 1-D Statistical Functions\n- `average`\n- `sum`\n- `num_vals`\n- `stddev`(population and"
  },
  {
    "path": "docs/tdigest.md",
    "chars": 15270,
    "preview": "# T-Digest\n\n> [Description](#tdigest-description)<br>\n> [Details](#tdigest-details)<br>\n> [Example](#tdigest-example)<br"
  },
  {
    "path": "docs/template.md",
    "chars": 1924,
    "preview": "# FEATURE-NAME [<sup><mark>experimental</mark></sup>](/docs/README.md#tag-notes)\n\n- Current status: ( prototype | experi"
  },
  {
    "path": "docs/test_caggs.md",
    "chars": 4536,
    "preview": "# Continuous aggregation tests\n\nThis document serves as a driver for allowing our doctester to verify the behavior of so"
  },
  {
    "path": "docs/test_candlestick_agg.md",
    "chars": 3441,
    "preview": "# Candlestick Continuous Aggregation Tests\n\n## Setup table\n```SQL,non-transactional,ignore-output\nSET TIME ZONE 'UTC';\nC"
  },
  {
    "path": "docs/time_weighted_average.md",
    "chars": 16446,
    "preview": "# Time Weighted Average\n\n> [Description](#time-weighted-average-description)<br>\n> [Example Usage](time-weighted-average"
  },
  {
    "path": "docs/timeseries.md",
    "chars": 6425,
    "preview": "# Timevector\n\n> [Description](#timevector-description)<br>\n> [Timevector Pipelines](#timevector-pipelines)<br>\n> [Exampl"
  },
  {
    "path": "docs/timeseries_pipeline_elements.md",
    "chars": 10175,
    "preview": "# Timevector Pipelines [<sup><mark>experimental</mark></sup>](/docs/README.md#tag-notes)\n\n> [Description](#timevector-pi"
  },
  {
    "path": "docs/two-step_aggregation.md",
    "chars": 11140,
    "preview": "# Two-Step Aggregation - What It Is and Why We Use It\n\n## What is a Two-Step Aggregate <a id=\"two-step-description\"></a>"
  },
  {
    "path": "docs/uddsketch.md",
    "chars": 16584,
    "preview": "# UddSketch\n\n> [Description](#uddsketch-description)<br>\n> [Details](#uddsketch-details)<br>\n> [Example](#uddsketch-exam"
  },
  {
    "path": "extension/.gitignore",
    "chars": 71,
    "preview": ".DS_Store\n.idea/\n.vscode/\n/target\n*.iml\n**/*.rs.bk\nsql/*.generated.sql\n"
  },
  {
    "path": "extension/Cargo.toml",
    "chars": 1917,
    "preview": "[package]\nname = \"timescaledb_toolkit\"\nversion = \"1.22.0-dev\"\nedition = \"2021\"\n\n[[bin]]\nname = \"pgrx_embed_timescaledb_t"
  },
  {
    "path": "extension/src/accessors/tests.rs",
    "chars": 441,
    "preview": "use pgrx::*;\n\nuse super::accessor;\n\n//use crate::{accessor, build};\n\n// TODO don't require that trailing comma\naccessor!"
  },
  {
    "path": "extension/src/accessors.rs",
    "chars": 15225,
    "preview": "use pgrx::*;\n\nuse counter_agg::range::I64Range;\n\nuse crate::{build, flatten, pg_type, ron_inout_funcs};\n\nmacro_rules! ac"
  },
  {
    "path": "extension/src/aggregate_builder_tests.rs",
    "chars": 7269,
    "preview": "// Tests for `aggregate_builder::aggregate`. This can't be in the\n// aggregate_builder crate because it requires too muc"
  },
  {
    "path": "extension/src/aggregate_utils.rs",
    "chars": 1282,
    "preview": "use std::ptr::null_mut;\n\nuse pgrx::pg_sys;\n\n// TODO move to func_utils once there are enough function to warrant one\npub"
  },
  {
    "path": "extension/src/asap.rs",
    "chars": 12968,
    "preview": "use asap::*;\nuse pgrx::*;\nuse serde::{Deserialize, Serialize};\n\nuse crate::{\n    aggregate_utils::in_aggregate_context,\n"
  },
  {
    "path": "extension/src/bin/pgrx_embed.rs",
    "chars": 86,
    "preview": "// so we can support upgrading pgrx\n#![allow(unexpected_cfgs)]\n::pgrx::pgrx_embed!();\n"
  },
  {
    "path": "extension/src/candlestick.rs",
    "chars": 38220,
    "preview": "use pgrx::*;\nuse serde::{Deserialize, Serialize};\n\nuse crate::accessors::{\n    AccessorClose, AccessorCloseTime, Accesso"
  },
  {
    "path": "extension/src/counter_agg/accessors.rs",
    "chars": 2642,
    "preview": "use pgrx::*;\n\nuse crate::{\n    counter_agg::{CounterSummary, CounterSummaryData, MetricSummary},\n    datum_utils::interv"
  },
  {
    "path": "extension/src/counter_agg.rs",
    "chars": 63559,
    "preview": "use serde::{Deserialize, Serialize};\n\nuse pgrx::*;\n\nuse crate::{\n    accessors::{\n        AccessorCorr, AccessorCounterZ"
  },
  {
    "path": "extension/src/countminsketch.rs",
    "chars": 9369,
    "preview": "use pgrx::*;\n\nuse aggregate_builder::aggregate;\nuse countminsketch::{CountMinHashFn, CountMinSketch as CountMinSketchInt"
  },
  {
    "path": "extension/src/datum_utils.rs",
    "chars": 24151,
    "preview": "use std::{\n    fmt,\n    hash::{BuildHasher, Hasher},\n    mem::size_of,\n    slice,\n};\n\nuse serde::{\n    de::{SeqAccess, V"
  },
  {
    "path": "extension/src/duration.rs",
    "chars": 3285,
    "preview": "//! Utilities for working with durations. Parsing of duration units is intended to match how\n//! PostgreSQL parses durat"
  },
  {
    "path": "extension/src/frequency.rs",
    "chars": 88784,
    "preview": "//! Based on the paper: https://cs.ucsb.edu/sites/default/files/documents/2005-23.pdf\n\nuse std::fmt;\n\nuse pgrx::{\n    it"
  },
  {
    "path": "extension/src/gauge_agg.rs",
    "chars": 40007,
    "preview": "use pgrx::*;\n\nuse serde::{Deserialize, Serialize};\n\nuse counter_agg::{range::I64Range, GaugeSummaryBuilder, MetricSummar"
  },
  {
    "path": "extension/src/heartbeat_agg/accessors.rs",
    "chars": 3874,
    "preview": "use pgrx::*;\n\nuse crate::{\n    flatten,\n    heartbeat_agg::{HeartbeatAgg, HeartbeatAggData},\n    pg_type, ron_inout_func"
  },
  {
    "path": "extension/src/heartbeat_agg.rs",
    "chars": 63409,
    "preview": "use pgrx::iter::TableIterator;\nuse pgrx::*;\n\nuse crate::{\n    accessors::{\n        AccessorDeadRanges, AccessorDowntime,"
  },
  {
    "path": "extension/src/hyperloglog.rs",
    "chars": 35429,
    "preview": "#![allow(clippy::identity_op)] // clippy gets confused by flat_serialize! enums\n\nuse std::{\n    convert::TryInto,\n    ha"
  },
  {
    "path": "extension/src/lib.rs",
    "chars": 2149,
    "preview": "// so we can support upgrading pgrx\n#![allow(unexpected_cfgs)]\n// so we can allow very new Clippy lints\n#![allow(unknown"
  },
  {
    "path": "extension/src/lttb.rs",
    "chars": 22545,
    "preview": "use pgrx::*;\nuse std::borrow::Cow;\n\nuse crate::{\n    aggregate_utils::in_aggregate_context,\n    flatten,\n    palloc::{In"
  },
  {
    "path": "extension/src/nmost/max_by_float.rs",
    "chars": 6369,
    "preview": "use pgrx::{iter::TableIterator, *};\n\nuse crate::nmost::max_float::*;\nuse crate::nmost::*;\n\nuse crate::{\n    build, flatt"
  },
  {
    "path": "extension/src/nmost/max_by_int.rs",
    "chars": 5995,
    "preview": "use pgrx::{iter::TableIterator, *};\n\nuse crate::nmost::max_int::*;\nuse crate::nmost::*;\n\nuse crate::{\n    build, flatten"
  },
  {
    "path": "extension/src/nmost/max_by_time.rs",
    "chars": 6699,
    "preview": "use pgrx::{iter::TableIterator, *};\n\nuse crate::nmost::max_time::*;\nuse crate::nmost::*;\n\nuse crate::{\n    build, flatte"
  },
  {
    "path": "extension/src/nmost/max_float.rs",
    "chars": 8546,
    "preview": "use pgrx::{iter::SetOfIterator, *};\n\nuse crate::nmost::*;\n\nuse crate::{\n    accessors::{AccessorIntoArray, AccessorIntoV"
  },
  {
    "path": "extension/src/nmost/max_int.rs",
    "chars": 7681,
    "preview": "use pgrx::{iter::SetOfIterator, *};\n\nuse crate::nmost::*;\n\nuse crate::{\n    accessors::{AccessorIntoArray, AccessorIntoV"
  },
  {
    "path": "extension/src/nmost/max_time.rs",
    "chars": 9090,
    "preview": "use pgrx::{iter::SetOfIterator, *};\n\nuse crate::nmost::*;\n\nuse crate::{\n    accessors::{AccessorIntoArray, AccessorIntoV"
  },
  {
    "path": "extension/src/nmost/min_by_float.rs",
    "chars": 6275,
    "preview": "use pgrx::{iter::TableIterator, *};\n\nuse crate::nmost::min_float::*;\nuse crate::nmost::*;\n\nuse crate::{\n    build, flatt"
  },
  {
    "path": "extension/src/nmost/min_by_int.rs",
    "chars": 5659,
    "preview": "use pgrx::{iter::TableIterator, *};\n\nuse crate::nmost::min_int::*;\nuse crate::nmost::*;\n\nuse crate::{\n    build, flatten"
  },
  {
    "path": "extension/src/nmost/min_by_time.rs",
    "chars": 6347,
    "preview": "use pgrx::{iter::TableIterator, *};\n\nuse crate::nmost::min_time::*;\nuse crate::nmost::*;\n\nuse crate::{\n    build, flatte"
  },
  {
    "path": "extension/src/nmost/min_float.rs",
    "chars": 8355,
    "preview": "use pgrx::{iter::SetOfIterator, *};\n\nuse crate::nmost::*;\n\nuse crate::{\n    accessors::{AccessorIntoArray, AccessorIntoV"
  },
  {
    "path": "extension/src/nmost/min_int.rs",
    "chars": 7390,
    "preview": "use pgrx::{iter::SetOfIterator, *};\n\nuse crate::nmost::*;\n\nuse crate::{\n    accessors::{AccessorIntoArray, AccessorIntoV"
  },
  {
    "path": "extension/src/nmost/min_time.rs",
    "chars": 8779,
    "preview": "use pgrx::{iter::SetOfIterator, *};\n\nuse crate::nmost::*;\n\nuse crate::{\n    accessors::{AccessorIntoArray, AccessorIntoV"
  },
  {
    "path": "extension/src/nmost.rs",
    "chars": 8470,
    "preview": "use pgrx::*;\n\nuse serde::{Deserialize, Serialize};\n\nuse crate::{\n    aggregate_utils::in_aggregate_context,\n    datum_ut"
  },
  {
    "path": "extension/src/palloc.rs",
    "chars": 5227,
    "preview": "use std::{\n    alloc::{GlobalAlloc, Layout, System},\n    ops::{Deref, DerefMut},\n    ptr::NonNull,\n};\n\nuse pgrx::*;\n\npub"
  },
  {
    "path": "extension/src/pg_any_element.rs",
    "chars": 4020,
    "preview": "use std::{\n    collections::HashMap,\n    hash::{Hash, Hasher},\n    mem::size_of,\n};\n\nuse pgrx::*;\n\nuse pg_sys::{Datum, O"
  },
  {
    "path": "extension/src/range.rs",
    "chars": 5088,
    "preview": "use counter_agg::range::I64Range;\nuse pgrx::{extension_sql, pg_sys};\nuse serde::{Deserialize, Serialize};\nuse std::conve"
  },
  {
    "path": "extension/src/raw.rs",
    "chars": 5836,
    "preview": "#![allow(non_camel_case_types)]\n\nuse pgrx::*;\nuse pgrx_sql_entity_graph::metadata::{\n    ArgumentError, Returns, Returns"
  },
  {
    "path": "extension/src/saturation.rs",
    "chars": 2645,
    "preview": "//! Saturating Math for Integers\n\nuse pgrx::*;\n\n/// Computes x+y, saturating at the numeric bounds instead of overflowin"
  },
  {
    "path": "extension/src/serialization/collations.rs",
    "chars": 11903,
    "preview": "use std::{\n    ffi::{CStr, CString},\n    mem::{align_of, size_of, MaybeUninit},\n    os::raw::c_char,\n    slice,\n};\n\nuse "
  },
  {
    "path": "extension/src/serialization/functions.rs",
    "chars": 2229,
    "preview": "use std::{\n    ffi::{CStr, CString},\n    mem::{align_of, size_of, MaybeUninit},\n    os::raw::c_char,\n    slice,\n};\n\nuse "
  },
  {
    "path": "extension/src/serialization/types.rs",
    "chars": 14199,
    "preview": "use std::{\n    ffi::{CStr, CString},\n    mem::{align_of, size_of, MaybeUninit},\n    slice,\n};\n\nuse flat_serialize::{impl"
  },
  {
    "path": "extension/src/serialization.rs",
    "chars": 5670,
    "preview": "pub use self::collations::PgCollationId;\npub use self::functions::PgProcId;\npub use self::types::ShortTypeId;\nuse std::{"
  },
  {
    "path": "extension/src/stabilization_info.rs",
    "chars": 53294,
    "preview": "// This file serves as the canonical database for what functionality Toolkit has\n// stabilized and in which version they"
  },
  {
    "path": "extension/src/stabilization_tests.rs",
    "chars": 9765,
    "preview": "#[cfg(any(test, feature = \"pg_test\"))]\nuse pgrx::*;\n\n#[cfg(any(test, feature = \"pg_test\"))]\n#[pg_schema]\nmod tests {\n   "
  },
  {
    "path": "extension/src/state_aggregate/accessors.rs",
    "chars": 9782,
    "preview": "use crate::{\n    datum_utils::interval_to_ms,\n    pg_type,\n    raw::{Interval, TimestampTz},\n    ron_inout_funcs,\n    st"
  },
  {
    "path": "extension/src/state_aggregate/rollup.rs",
    "chars": 19356,
    "preview": "use super::{toolkit_experimental::*, *};\nuse crate::{\n    aggregate_utils::in_aggregate_context,\n    palloc::{InternalAs"
  },
  {
    "path": "extension/src/state_aggregate.rs",
    "chars": 92202,
    "preview": "//! SELECT duration_in('STOPPED', states) as run_time, duration_in('ERROR', states) as error_time FROM (\n//!   SELECT co"
  },
  {
    "path": "extension/src/stats_agg.rs",
    "chars": 73610,
    "preview": "use pgrx::*;\n\nuse crate::{\n    accessors::{\n        AccessorAverage, AccessorAverageX, AccessorAverageY, AccessorCorr, A"
  },
  {
    "path": "extension/src/tdigest.rs",
    "chars": 25850,
    "preview": "use std::{convert::TryInto, ops::Deref};\n\nuse pgrx::*;\n\nuse crate::{\n    accessors::{\n        AccessorApproxPercentile, "
  },
  {
    "path": "extension/src/time_vector/iter.rs",
    "chars": 850,
    "preview": "use tspoint::TSPoint;\n\nuse Iter::*;\n\npub enum Iter<'a> {\n    Slice {\n        iter: flat_serialize::Iter<'a, 'a, TSPoint>"
  },
  {
    "path": "extension/src/time_vector/pipeline/aggregation.rs",
    "chars": 47740,
    "preview": "use std::mem::take;\n\nuse pgrx::*;\n\nuse counter_agg::CounterSummaryBuilder;\n\nuse super::*;\n\nuse crate::{\n    accessors::{"
  },
  {
    "path": "extension/src/time_vector/pipeline/arithmetic.rs",
    "chars": 22252,
    "preview": "use pgrx::*;\n\nuse super::*;\n\nuse super::Element::Arithmetic;\nuse Function::*;\n\n#[derive(\n    Debug, Copy, Clone, flat_se"
  },
  {
    "path": "extension/src/time_vector/pipeline/delta.rs",
    "chars": 4421,
    "preview": "use pgrx::*;\n\nuse super::*;\n\nuse crate::accessors::AccessorDelta;\n\n// TODO is (immutable, parallel_safe) correct?\n#[pg_e"
  },
  {
    "path": "extension/src/time_vector/pipeline/expansion.rs",
    "chars": 11212,
    "preview": "use std::mem::take;\n\nuse pgrx::{iter::TableIterator, *};\n\nuse super::*;\n\nuse crate::{build, pg_type, ron_inout_funcs};\n\n"
  },
  {
    "path": "extension/src/time_vector/pipeline/fill_to.rs",
    "chars": 10461,
    "preview": "use pgrx::*;\n\nuse flat_serialize_macro::FlatSerializable;\n\nuse serde::{Deserialize, Serialize};\n\nuse super::*;\n\n// TODO:"
  },
  {
    "path": "extension/src/time_vector/pipeline/filter.rs",
    "chars": 4540,
    "preview": "use pgrx::*;\n\nuse super::*;\n\n// TODO is (stable, parallel_safe) correct?\n#[pg_extern(\n    immutable,\n    parallel_safe,\n"
  },
  {
    "path": "extension/src/time_vector/pipeline/lambda/executor.rs",
    "chars": 12482,
    "preview": "use pgrx::*;\n\nuse super::*;\n\npub struct ExpressionExecutor<'e, T> {\n    exprs: &'e Expression,\n    var_vals: Vec<Option<"
  },
  {
    "path": "extension/src/time_vector/pipeline/lambda/lambda_expr.pest",
    "chars": 1254,
    "preview": "calculation = _{ SOI ~ let_expr ~ EOI }\nlet_expr = { (\"let\" ~ var ~ \"=\" ~ tuple ~ \";\")* ~ tuple }\ntuple = { binops ~ (\","
  },
  {
    "path": "extension/src/time_vector/pipeline/lambda/parser.rs",
    "chars": 16377,
    "preview": "use std::{collections::HashMap, ffi::CString};\n\nuse pgrx::*;\n\nuse super::*;\n\nuse pest::{\n    iterators::{Pair, Pairs},\n "
  },
  {
    "path": "extension/src/time_vector/pipeline/lambda.rs",
    "chars": 30610,
    "preview": "use std::borrow::Cow;\n\nuse pgrx::{\n    iter::{SetOfIterator, TableIterator},\n    *,\n};\n\nuse super::*;\n\npub use executor:"
  },
  {
    "path": "extension/src/time_vector/pipeline/map.rs",
    "chars": 29599,
    "preview": "use std::{\n    mem::{self, ManuallyDrop, MaybeUninit},\n    ptr,\n};\n\nuse pgrx::*;\n\nuse super::*;\n\nuse crate::serializatio"
  },
  {
    "path": "extension/src/time_vector/pipeline/sort.rs",
    "chars": 5096,
    "preview": "use pgrx::*;\n\nuse super::*;\n\n// TODO is (immutable, parallel_safe) correct?\n#[pg_extern(\n    immutable,\n    parallel_saf"
  },
  {
    "path": "extension/src/time_vector/pipeline.rs",
    "chars": 18249,
    "preview": "mod aggregation;\nmod arithmetic;\nmod delta;\nmod expansion;\nmod fill_to;\nmod filter;\nmod lambda;\nmod map;\nmod sort;\n\nuse "
  },
  {
    "path": "extension/src/time_vector.rs",
    "chars": 36277,
    "preview": "#![allow(clippy::identity_op)] // clippy gets confused by pg_type! enums\n\nuse crate::pg_sys::timestamptz_to_str;\nuse cor"
  },
  {
    "path": "extension/src/time_weighted_average/accessors.rs",
    "chars": 3520,
    "preview": "use pgrx::*;\n\nuse crate::time_weighted_average::DurationUnit;\nuse crate::{\n    datum_utils::interval_to_ms,\n    flatten,"
  },
  {
    "path": "extension/src/time_weighted_average.rs",
    "chars": 38463,
    "preview": "#![allow(non_camel_case_types)]\n\nuse pgrx::*;\nuse serde::{Deserialize, Serialize};\n\nuse crate::{\n    accessors::{\n      "
  },
  {
    "path": "extension/src/type_builder.rs",
    "chars": 32954,
    "preview": "#[derive(Copy, Clone, Debug, serde::Serialize)]\npub enum CachedDatum<'r> {\n    None,\n    FromInput(&'r [u8]),\n    Flatte"
  },
  {
    "path": "extension/src/uddsketch.rs",
    "chars": 42413,
    "preview": "use pgrx::*;\n\nuse encodings::{delta, prefix_varint};\n\nuse uddsketch::{SketchHashKey, UDDSketch as UddSketchInternal, UDD"
  },
  {
    "path": "extension/src/utilities.rs",
    "chars": 8445,
    "preview": "use crate::raw::TimestampTz;\nuse pgrx::prelude::*;\n\n#[pg_extern(\n    name = \"generate_periodic_normal_series\",\n    schem"
  },
  {
    "path": "extension/timescaledb_toolkit.control",
    "chars": 565,
    "preview": "comment = 'Library of analytical hyperfunctions, time-series pipelining, and other SQL utilities'\ndefault_version = '@CA"
  },
  {
    "path": "tests/update/candlestick.md",
    "chars": 1362,
    "preview": "# Candlestick Tests\n\n## Get candlestick values from tick data\n\n\n```sql,creation,min-toolkit-version=1.14.0\nCREATE TABLE "
  },
  {
    "path": "tests/update/heartbeat.md",
    "chars": 1890,
    "preview": "# Candlestick Tests\n\n## Get candlestick values from tick data\n\n\n```sql,creation,min-toolkit-version=1.15.0\nCREATE TABLE "
  },
  {
    "path": "tests/update/original_update_tests.md",
    "chars": 1166,
    "preview": "# Original Update Tests\n\n\n\n```sql,creation,min-toolkit-version=1.4.0\nCREATE TABLE test_data(ts timestamptz, val DOUBLE P"
  },
  {
    "path": "tests/update/state_agg.md",
    "chars": 942,
    "preview": "# `state_agg` tests\n\n```sql,creation,min-toolkit-version=1.15.0\nCREATE TABLE states_test(ts TIMESTAMPTZ, state TEXT);\nIN"
  },
  {
    "path": "tests/update/time-vector.md",
    "chars": 1510,
    "preview": "# Time Vector Tests\n\n```sql,creation\nCREATE TABLE time_vector_data(time TIMESTAMPTZ, value DOUBLE PRECISION);\nINSERT INT"
  },
  {
    "path": "tests/update/time-weighted-average.md",
    "chars": 1845,
    "preview": "# Time Weighted Average Tests\n\n## Test integral and interpolated integral\n\n```sql,creation,min-toolkit-version=1.15.0\nCR"
  },
  {
    "path": "tools/build",
    "chars": 3947,
    "preview": "#!/bin/sh\n\nset -ex\n\nprint() {\n    printf '%s\\n' \"$*\"\n}\n\ndie() {\n    st=${?:-0}\n    if [ $st -eq 0 ]; then\n        st=2\n "
  },
  {
    "path": "tools/dependencies.sh",
    "chars": 1029,
    "preview": "# Dependency configuration\n# Ideally, all dependencies would be specified in just one place.\n# Exceptions:\n# - crate dep"
  },
  {
    "path": "tools/install-timescaledb",
    "chars": 252,
    "preview": "#!/bin/sh\ngit clone \"$2\" timescaledb\ncd timescaledb\ngit switch --detach \"$3\"\nmkdir build\ncd build\n# this overwrites the "
  },
  {
    "path": "tools/post-install/Cargo.toml",
    "chars": 114,
    "preview": "[package]\nname = \"post-install\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nxshell = \"0.1.17\"\nwalkdir = \"2\""
  },
  {
    "path": "tools/post-install/src/main.rs",
    "chars": 10366,
    "preview": "#![allow(unexpected_cfgs)]\n\nuse std::{\n    env,\n    fs::{self, File},\n    io::{BufRead, BufReader, BufWriter, Write},\n  "
  },
  {
    "path": "tools/post-install/src/update_script.rs",
    "chars": 22283,
    "preview": "use std::{\n    collections::HashSet,\n    io::{BufRead, Write},\n    iter::Peekable,\n};\n\nuse crate::PushLine;\n\nstatic ALTE"
  },
  {
    "path": "tools/release",
    "chars": 12081,
    "preview": "#!/bin/sh\n\n# This script automates release creation:\n# 1. Create release branch from target commit.\n# 1a. Validate conte"
  },
  {
    "path": "tools/sql-doctester/Cargo.toml",
    "chars": 432,
    "preview": "[package]\nname = \"sql-doctester\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nbytecount = \"0.6.2\"\nclap = { version"
  },
  {
    "path": "tools/sql-doctester/Readme.md",
    "chars": 4210,
    "preview": "## SQL Doctester ##\n\nTest SQL code in Markdown files.\n\nThis tool looks through a directory for markdown files containing"
  },
  {
    "path": "tools/sql-doctester/src/main.rs",
    "chars": 3520,
    "preview": "use std::{\n    collections::HashMap,\n    ffi::OsStr,\n    fs,\n    io::{self, Write},\n    process::exit,\n};\n\nuse colored::"
  },
  {
    "path": "tools/sql-doctester/src/parser.rs",
    "chars": 12218,
    "preview": "use std::collections::HashMap;\n\nuse pulldown_cmark::{\n    CodeBlockKind::Fenced,\n    CowStr, Event, Parser,\n    Tag::{Co"
  },
  {
    "path": "tools/sql-doctester/src/runner.rs",
    "chars": 13656,
    "preview": "use rayon::{iter::ParallelIterator, prelude::*};\n\nuse std::{borrow::Cow, error::Error, fmt};\n\nuse colored::Colorize;\n\nus"
  },
  {
    "path": "tools/sql-doctester/src/startup.sql",
    "chars": 292,
    "preview": "CREATE EXTENSION timescaledb;\nCREATE EXTENSION timescaledb_toolkit;\nSET SESSION TIMEZONE TO 'UTC';\n\n-- utility for gener"
  },
  {
    "path": "tools/testbin",
    "chars": 8769,
    "preview": "#!/bin/sh\n\n# This script automates binary upgrade testing.\n\n# Sample run:\n# OS_NAME=ubuntu OS_VERSION=24.04 tools/testbi"
  },
  {
    "path": "tools/update-tester/Cargo.toml",
    "chars": 596,
    "preview": "[package]\nname = \"update-tester\"\nversion = \"0.3.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://do"
  },
  {
    "path": "tools/update-tester/Readme.md",
    "chars": 1870,
    "preview": "# Update Tester #\n\nRuns update tests. It'll install every version of the extension marked as\n`upgradeable_from` in `time"
  },
  {
    "path": "tools/update-tester/src/installer.rs",
    "chars": 6830,
    "preview": "#![allow(unexpected_cfgs)]\n\nuse std::{collections::HashSet, path::Path};\n\nuse colored::Colorize;\nuse semver::Version;\nus"
  },
  {
    "path": "tools/update-tester/src/main.rs",
    "chars": 13637,
    "preview": "use std::{\n    collections::HashSet,\n    io::{self, Write},\n    path::Path,\n    process,\n};\n\nuse clap::Arg;\nuse clap::Co"
  },
  {
    "path": "tools/update-tester/src/parser.rs",
    "chars": 16294,
    "preview": "use std::{collections::HashMap, ffi::OsStr, fs, path::Path};\n\nuse pulldown_cmark::{\n    CodeBlockKind::Fenced,\n    CowSt"
  },
  {
    "path": "tools/update-tester/src/testrunner/stabilization.rs",
    "chars": 1776,
    "preview": "pub use stabilization_info::*;\n\n#[path = \"../../../../extension/src/stabilization_info.rs\"]\nmod stabilization_info;\n\n#[m"
  },
  {
    "path": "tools/update-tester/src/testrunner.rs",
    "chars": 24491,
    "preview": "use colored::Colorize;\nuse semver::{BuildMetadata, Prerelease, Version};\n\nuse crate::{defer, parser, Deferred};\nuse post"
  }
]